The AWS SDK v1 to v2 Migration Is Maximo Manage's Silent Customization Killer: Find Your Exposure Before the Fix Pack Finds You
IBM is swapping the bundled AWS SDK for Java from v1 to v2 inside ordinary Maximo Manage fix packs, and any automation script or library that imports com.amazonaws.* stops compiling the moment the pack lands. This article maps the affected releases, shows how to enumerate your exposure before…
The AWS SDK v1 to v2 Migration Is Maximo Manage's Silent Customization Killer: Find Your Exposure Before the Fix Pack Finds You
There is a class of Maximo Manage change that generates no banners, no webinars, and no urgent client advisories, yet silently breaks working customizations the moment a routine fix pack lands. The migration of the bundled AWS SDK for Java from version 1 to version 2 is exactly that kind of change. IBM has announced that the AWS SDK for Java bundled inside Maximo Manage is moving from the 1.x line to the 2.x line, specifically software.amazon.awssdk 2.41.34, and that the older v1 JARs, including aws-java-sdk-s3, aws-java-sdk-core, and aws-java-sdk-kms at version 1.12.651, are being removed from the product distribution. The delivery vehicles are refreshingly ordinary: Maximo 9.0.29, Maximo 9.1.21, Maximo 9.2.2, and the September feature channel for Maximo 9.3. Nothing about that list suggests urgency, which is precisely the problem.
The consequence is stark and easy to state. Every automation script, every custom Java class, and every server-side library that imports com.amazonaws.* will stop working after the fix pack is applied. Not degrade. Not warn. Stop working, with class-not-found errors in the log and script launches that fail on the first line. Because these imports typically live inside library automation scripts or custom business logic that teams wrote years ago to push documents to S3 or to interact with other AWS services, the failure often surfaces in workflows that run at the edge of the system: nightly document exports, attachment archival jobs, integrations to external data platforms. Those are exactly the components nobody tests during patch weekend.
This article treats the AWS SDK migration as a concrete engineering problem rather than an abstract announcement. We will work through which releases carry the change, why the v1 to v2 break is structural rather than cosmetic, how to inventory your automation script repository for exposure using nothing more complicated than a database query, and how to migrate the common script patterns from v1 to v2 with before and after code. We will also cover the testing sequence that minimizes the chance of discovering the break in production, and the special considerations for teams running the September feature channel on Maximo 9.3, where feature channel mechanics change the risk profile. If you apply fix packs to Maximo Manage, this change is coming to your environment, whether or not you currently use AWS services.
What Actually Changed, Release by Release
The first thing to understand is that this is a product-level JAR swap, not a new integration feature. Maximo Manage has shipped the AWS SDK for Java inside its distribution for years, originally to support product functions that interact with AWS services, most notably S3-based document storage connectivity. Custom development teams discovered the bundled JARs and began importing them directly from automation scripts, because the classes were right there on the classpath and required no additional deployment steps. That convenience created invisible coupling between customer customizations and an IBM internal dependency. When IBM modernizes that dependency, the coupling breaks.
The removal is specific and enumerable. The v1 JARs leaving the distribution are aws-java-sdk-s3, aws-java-sdk-core, and aws-java-sdk-kms, all at version 1.12.651. The replacement is the v2 SDK at software.amazon.awssdk 2.41.34, which uses a completely different package namespace: software.amazon.awssdk.* instead of com.amazonaws.*. That namespace difference is the crux of the break. This is not a minor version bump where deprecated methods linger for a release or two. The v2 SDK is a ground-up rewrite with different class names, different method signatures, different builder patterns, and different exception hierarchies. Code written against v1 does not compile against v2, full stop.
The delivery vehicles tell you who is exposed. Maximo 9.0.29 and 9.1.21 are product releases for estates on earlier Manage versions, meaning many teams will encounter this change during the upgrade work they are already doing to close the Maximo 7.6.1 entitlement gap, which closed for extended support at the end of September 2026. Maximo 9.2.2 is the fix pack line for the current mainstream release, meaning ordinary patch maintenance carries the change. And Maximo 9.3 receives it through the September feature channel, which introduces a subtlety worth pausing on. Feature channel content is additive and opt-in by nature, but once the channel content is applied and the stack reconfigures, the JAR swap applies just the same. Teams on 9.3 who defer the feature channel get a false sense of security; the day they accept it, the same com.amazonaws.* break arrives.
One more nuance deserves attention. Because the removed JARs vanish from the distribution, this is not a case where a system administrator can simply drop the v1 JARs back into an external classpath directory and carry on indefinitely. Reintroducing v1 JARs alongside the v2 SDK is technically possible for a bridge period, but it doubles the classpath surface, invites classloading conflicts between the two SDK generations, and puts you in unsupported territory for a bundled dependency IBM has explicitly removed. It is a reasonable short-term containment move for a broken production integration with a hard deadline. It is a terrible long-term plan. The migration is the plan.
Why v1 to v2 Breaks Code Structurally, Not Cosmetically
It is worth spending a few minutes on why this migration is so binary, because understanding the structure of the break helps you estimate the true scope of your remediation work. The AWS SDK for Java v2 is not a refactor of v1. It is a deliberate redesign, and the design decisions are visible in every line of affected code.
The most visible change is the package namespace. In v1, your code imported com.amazonaws.services.s3.AmazonS3ClientBuilder and friends. In v2, the equivalent client lives at software.amazon.awssdk.services.s3.S3Client. Your imports, and therefore every file that contains them, must change. There is no compatibility shim in the v2 JARs, because the two SDKs are entirely separate artifacts with separate coordinates. When the v1 JARs leave the Maximo distribution, the classes those imports refer to simply do not exist anymore, and the script engine reports the failure at the first reference.
The second structural change is the shift from the v1 static builder pattern to the v2 client builder pattern with explicit credential and region objects. In v1, you could write AmazonS3ClientBuilder.standard().withCredentials(...).withRegion(...).build() and the SDK would paper over a fair amount of configuration. In v2, you write S3Client.builder().region(Region.US_EAST_1).credentialsProvider(...).build(), and both region and credentials are explicit, required, and strongly typed. The v2 SDK removed default region inference that v1 offered in several contexts, on the theory that implicit region selection caused more production incidents than it prevented. For Maximo script authors, that means scripts that worked without specifying a region, because the v1 SDK found one in the environment, may now need the region passed explicitly.
The third change is the request and response object model. v1 method calls took and returned objects like PutObjectRequest and PutObjectResult from the com.amazonaws.services.s3.model package. v2 uses software.amazon.awssdk.services.s3.model.PutObjectRequest and returns PutObjectResponse, with different accessor names throughout. Method-level changes follow the same pattern: putObject exists in both, but the overloads differ, and operations like listObjects renamed request and result classes and changed pagination handling to a paginator-based model. Exception types moved as well; com.amazonaws.services.s3.model.AmazonS3Exception becomes software.amazon.awssdk.services.s3.model.S3Exception, and the broader com.amazonaws.AmazonServiceException hierarchy is replaced by software.amazon.awssdk.core.exception.SdkServiceException and friends. Catch blocks that reference v1 exception types will not compile against v2.
For automation scripts specifically, there is an additional wrinkle: jython's import mechanics and the Maximo script engine's classpath behavior. Automation scripts in Maximo Manage run on the server classpath, so they resolve whatever JARs the product distribution provides. A library script that imports com.amazonaws.* compiles on first use and caches. After the fix pack, that cached compilation fails to resolve, and depending on how the script was registered and whether it has a launch point, the failure appears either at script save time, at first invocation, or at activation of the containing process. Teams that do not test AWS-touching scripts during patch validation are effectively deferring that discovery to the first production invocation.
Inventory Your Exposure: Find Every com.amazonaws Import
Before any migration work, you need an exposure inventory, and the good news is that Maximo gives you the data to build one with a single query. Automation scripts live in the MAXSCRIPT table, with source in the SOURCE column and compiled bytecode in a related blob column. Custom library scripts, launch point scripts, and action scripts that touch AWS services will contain the com.amazonaws import string in their source. The query is straightforward.
Run something like this against your Maximo database, adjusting for your database platform's syntax for case-insensitive matching and large text search: select SCRIPTNAME, LAUNCHPOINTS, and the relevant metadata from MAXSCRIPT where upper(SOURCE) like '%COM.AMAZONAWS%'. On Oracle you might write it as select scriptname from maxscript where upper(source) like '%COM.AMAZONAWS.AMAZONS3%' to narrow straight to S3 usage, or broaden the pattern to '%COM.AMAZONAWS%' to catch everything including KMS, SQS, and any other v1 service clients. Add a union against the CUSTCODE table if your organization keeps custom Java classes registered there, and do not forget the LIBRARY scripts, which frequently hold shared utility code that other scripts call, meaning one infected library can cascade into a dozen dependent scripts.
The inventory should classify each hit into three buckets. The first bucket is direct AWS usage inside scripts: code that constructs clients, transfers files, or calls services. These need the code migration described in the next section. The second bucket is copy-paste scaffolding: script headers that import AWS classes defensively or boilerplate that was pasted from an older template but never actually used. These still break, because the import alone is fatal, but the fix is often deletion rather than migration. The third bucket is indirect exposure: scripts that call library scripts which hold the AWS code. These do not contain com.amazonaws strings themselves, but they fail when the library fails, so your inventory must walk the dependency chain. Grep the SOURCE column for calls into any library script your first query flagged.
Extend the inventory beyond automation scripts. Custom Java classes deployed to the Maximo application server, whether registered in CUSTCODE or deployed as additional JARs, may carry the same imports. Report object extensions, custom beans, and escalation framework classes are all candidates. If your organization has historically dropped third-party JARs into the application server's lib directories, check those directories for v1 AWS JARs that are about to become either orphaned or conflicting once the product ships v2. A file-level find for aws-java-sdk*.jar across the Maximo deployment directories tells you what is physically present. Finally, interview the integration team, because the highest-risk code is the code nobody remembers writing, such as the S3 archival job a consultant built in 2021 and left running quietly ever since.
The output of this step is a register: every script name, its bucket classification, its business owner if known, its invocation pattern (cron-style escalation, launch point, or manual), and its criticality. That register drives both the migration schedule and the post-patch test plan. Teams that skip the inventory and rely on memory will miss the quiet scripts, and the quiet scripts are the ones that fail at 2 AM on the first business day after patch weekend.
Migrating Script Code from v1 to v2: Patterns That Work
The migration itself is mechanical once you see the pattern. Almost every Maximo automation script that used the v1 S3 client follows one of three shapes: uploading a file to a bucket, downloading or fetching an object, or generating a presigned URL for a document link. Each shape translates cleanly to v2, and showing the translations side by side is the fastest way to plan the work.
Consider the upload shape. In v1, a Maximo script might read a file from the attached documents directory and push it to S3 with code like this. The script imports com.amazonaws.services.s3.AmazonS3ClientBuilder and com.amazonaws.auth.BasicAWSCredentials, constructs an AmazonS3 client with a region string, calls putObject with a bucket name, key, and java.io.File, and closes the implicit client when the script ends. The v2 equivalent imports software.amazon.awssdk.services.s3.S3Client, software.amazon.awssdk.auth.credentials.AwsBasicCredentials, and software.amazon.awssdk.regions.Region. The construction changes to S3Client.builder().region(Region.of("us-east-1")).credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(key, secret))).build(). The upload changes to client.putObject(PutObjectRequest.builder().bucket(bucket).key(key).build(), RequestBody.fromFile(new java.io.File(path))). In Maximo jython, the RequestBody class needs its fully qualified name in many script engine versions, so software.amazon.awssdk.core.sync.RequestBody.fromFile(path) is the safe spelling. The client should be closed in a finally block, and v2 clients implement AutoCloseable, so the finally close is both required and clean.
The presigned URL shape changes more substantially, because v2 moved URL generation into a separate presigner object. In v1, the script called client.generatePresignedUrl with a GeneratePresignedUrlRequest. In v2, you build a S3Presigner with its own builder, wrapping the same region and credentials, then call presigner.presignGetObject(GetObjectPresignRequest.builder().signatureDuration(java.time.Duration.ofMinutes(15)).getObjectRequest(GetObjectRequest.builder().bucket(bucket).key(key).build()).build()) and take the url from the result. The presigner is also AutoCloseable and should be closed when the script finishes. Scripts that generate document links for users must be tested with the actual Maximo UI document link flow, because the v2 presigner emits URLs in the same format but the expiry and header behavior can differ subtly at the edges.
Two practical notes for the jython environment. First, method name casing matters and jython resolves v2 builder methods exactly as named; if you paste code that was written for the Java language level your Manage version does not support, certain builder calls may need adjustment, so test compile every migrated script before patch weekend, not after. Second, credential handling deserves a deliberate decision rather than a copy-paste. Embedding access keys in script source has always been poor practice, and the migration is the natural moment to move credentials to an environment configuration, a secure store, or Maximo's system properties where your organization already manages secrets. The v2 SDK's credentials provider chain reads standard AWS environment variables and profiles, which the v1 SDK also did, so a per-server environment configuration often removes credentials from script bodies entirely. That is a security posture improvement you get for free by doing the migration properly instead of minimally.
Testing, Feature Channel Mechanics, and the 9.3 Wrinkle
The right testing sequence starts before the fix pack is applied and uses your exposure register as the test plan. For each script in the register, identify the trigger mechanism and record a pre-patch validation result. Escalation-driven scripts can be run manually once with a controlled input. Launch point scripts can be fired through a test record in a dev environment. Library scripts should be exercised through their most important caller, because the library compiling is not the same as the library working.
Test compilation in the target environment is the critical gate. The structural break is at the class resolution layer, so the only trustworthy test is to save and compile the migrated script against a Manage instance that already has the v2 SDK, which means a dev or staging environment running the same fix pack or feature channel level you intend to apply. A staging environment one fix pack behind tells you nothing about this break, because the v1 JARs are still present there and the old code compiles happily. Teams that test migrations against a stale staging environment get a green light that turns red on production patch night. If standing up a current staging instance is expensive, the second-best option is a standalone JVM with the v2 SDK on the classpath and the script bodies extracted into a harness, which at least validates imports and call shapes, even though it cannot validate the Maximo script engine's save-time behavior.
The feature channel wrinkle on Maximo 9.3 deserves its own paragraph. Feature channel content in MAS is designed to let administrators adopt new function at a controlled pace rather than absorbing everything in one upgrade. That flexibility is valuable, but for dependency swaps like this one it creates a trap. The AWS SDK change is not a feature you can decline while accepting others in the same channel drop, and more importantly, teams that defer the September channel on one environment but apply it on another end up with split behavior across their estate. Dev accepts the channel, production defers, and migrated scripts that assume v2 sit next to unmigrated scripts that assume v1 in different environments. The mitigation is coordination: make the channel acceptance decision once, apply it environment by environment in the same window as the script migration, and keep the exposure register as the tracking artifact until every environment has crossed.
The post-patch smoke test should include at least one end-to-end run of each AWS-touching workflow, not just the script save. Upload a real file through the actual document attachment path. Fetch a real object and validate the content. Generate a presigned URL and open it in a browser. Verify error handling by pointing a test call at a nonexistent bucket and confirming the script catches the v2 exception type rather than crashing. Exception handling is where migrations quietly fail testing, because the happy path compiles and runs while the catch blocks still reference v1 exception classes that no longer exist. If any catch block references com.amazonaws.*, the whole script fails to compile even though the try block was migrated correctly. Grep your migrated scripts for com.amazonaws after migration and treat any hit as a defect, including in comments if you want zero ambiguity about what remains.
Practical Implications
The immediate implication for Maximo Manage teams is calendar-driven. If your environment runs Maximo 9.0, 9.1, or 9.2 and you apply fix packs on a regular cadence, this change is in your near-term patch stream, and the time to inventory and migrate is now, not patch week. Teams mid-upgrade from 7.6.1 face a compounding effect: the upgrade itself is disruptive, and an un-migrated AWS integration that breaks during upgrade validation can be misread as an upgrade defect, costing hours of misdirected troubleshooting. Do the SDK migration before or clearly separated from the upgrade, so failures have one obvious cause.
Budget-wise, the honest estimate is that a single straightforward S3 script migration is a day of work including testing, and an estate with several scripts plus a shared library is a week or two of elapsed effort spread across developers who may not have touched the code in years. The register you built in the inventory step is what turns that from an open-ended fear into a scoped work package. Where original authors have left, the before and after patterns in this article cover the common shapes well enough to migrate without domain archaeology.
For teams on 9.3, the feature channel decision should be an explicit line item in the change plan, agreed between the Maximo administrator and the integration owners. For everyone, the broader lesson generalizes: bundled JARs inside a platform distribution are product internals, no matter how convenient they are to import from scripts. This will not be the last time a platform modernizes a dependency that customer code quietly depends on, and the estates that suffer least are the ones that keep an explicit register of what their customizations touch, so that when an announcement like this lands, the exposure question is a query rather than a mystery.
The Bottom Line
IBM is replacing the bundled AWS SDK for Java v1 with v2 in Maximo Manage 9.0.29, 9.1.21, 9.2.2, and the September feature channel for 9.3, and every script or class importing com.amazonaws.* breaks the moment the change lands. The break is structural: different package namespace, different client builders, different request and response classes, different exception hierarchy. There is no compatibility mode and no supported way to keep v1 forever.
Your exposure is enumerable with a database query against MAXSCRIPT, plus a check of custom Java code and deployed JAR directories. Migration is mechanical for the three common script shapes, upload, download, and presigned URL, and the v2 patterns are cleaner than the v1 originals. Test compile against a current-level environment, walk the dependency chain from library scripts to their callers, and grep for residual com.amazonaws references before you call any script done.
The window between now and your next fix pack application is the window in which this work is cheap. After the pack lands, the same work becomes urgent, interrupt-driven, and tangled with whatever else patch validation surfaces. Run the query this week, size the register, and slot the migration into the sprint before your next patch cycle. The silent customization killer is only silent until patch day, and by then the sound it makes is a production integration failing overnight.