Assetize

Learning Lab

Level 12 · 15 levels · Builder · about 75 minutes

Level 12 — mxH: your Maximo upgrade is a diff

By the end: Explain why upgrades hurt, say what mxH reads and which releases it ships, read a finding by its grade and evidence class, walk the Kestrel Energy sample from 7.6.1.3 to 9.2, open a finding in the Studio, and explain mxH to an engineer and to a buyer.

Two sets meet: everything IBM changed between two releases, and everything your customer changed in their own Maximo. mxH reports the overlap, because that is the part that costs money.

Two overlapping sets: what IBM changed between the two releases, and the customer's own customisations. Only the overlap is highlighted: the changes that touch the customer's own lines.

Lesson 1

Why upgrades hurt: your changes meet IBM's changes

Every Maximo that has been running for a few years has been changed by its owner. Someone added fields to the asset table. Someone wrote automation scripts that check a work order before it can be completed. A contractor wrote a Java class that extends a Maximo business object. Screens were moved around in Application Designer. Reports were written in BIRT. Integrations were built to send work orders to the finance system. All of these are called customisations: changes the customer made on top of what IBM ships.

Between two releases, IBM changes the product too. It removes attributes. It changes a field's type, length or number of decimal places. It deletes Java classes and methods. It moves the platform: classic Maximo 7.6.1 ran on WebSphere servers, while Maximo Application Suite (MAS) runs in containers on Red Hat OpenShift. It moves Java forward: IBM says Manage 9.1 runs on Java 17 and that you recompile your customisation archives, and Manage 9.2 supports Java 25. It retires old ways in: Maximo Manage does not support RMI, so external programs use the REST API instead, and the user-management APIs deprecated in 9.1 are removed in 9.2.

The layers of change. Read the stack from the top. Configuration is light to change and light to upgrade. Each layer down costs more to build and carries more upgrade risk. Java sits at the bottom: it compiles against IBM's own classes, so when IBM moves a class, Java is the first thing to break.

A stack from light to heavy: configuration at the top, then automation scripts, then integration, reports and mobile, then Java at the bottom. Two meters show effort and upgrade risk growing as you go down.

An upgrade hurts where those two sets of change meet. IBM's change on its own is fine: IBM tests its own product. Your customer's change on its own is fine: it works today. The pain is a customer line that depends on something IBM changed. A script reads an attribute IBM removed. A Java class imports a class IBM deleted. An integration expects a field to be 30 characters and now gets 100.

What IBM changedWhat it can break in a customisationHow it shows up
An attribute removedA script or report that reads or writes itA read throws and a write fails, the first time that line runs
A field's type or scale changed (INTEGER to DECIMAL, scale 0 to 2)Arithmetic, rounding, totals, integration mappingsWrong numbers, often quietly
A field's length changedAn interface or report that pads, truncates or validates lengthRejected messages or cut-off text
A Java class or method removedCustom Java that imports or calls itThe class will not compile, or a call fails at run time
A column made non-persistentSQL, reports and joins on that columnQueries break even though the business object still reads it
RMI and old login methods retiredIntegrations that call in the old wayCalls refused with 401 or no connection at all

This is the whole problem in one sentence: you do not need to know everything IBM changed. You need to know which of IBM's changes touch your customer's own lines. Assetize's Compare page lists 190 changes to absorb between 7.6.1.3 and 9.2, across 22 functional areas. A customer might be hit by five of them, or fifty. Reading all 190 and guessing is slow, and it misses things.

Your upgrade is a diff. Watch the two sets slide together. The left set is IBM's change between the two releases. The right set is the customer's own customisations. Only the overlap lights up: those are the lines of the upgrade that belong to this customer.

Two overlapping sets: what IBM changed between the two releases, and the customer's own customisations. Only the overlap is highlighted: the changes that touch the customer's own lines.

The mistake: Read every IBM release note, make a long list of everything that changed, and ask the customer's team to check all of it. Do this instead: Compare IBM's changes against the customer's own dictionary, code and screens, and work only the overlap. Everything outside it is IBM's job, and IBM has already tested it.

Remember: An upgrade is not "what did IBM change?". It is "which of IBM's changes hit our own lines?". That second question is what mxH answers.

Lesson 2

What mxH reads, and the releases it ships

mxH is an Assetize product. Its own description is "Evidence-driven Maximo upgrade intelligence across versions — connecting IBM product changes to what they mean for your Maximo." Its hook line, the sentence a page leads with, is "Your Maximo upgrade is a diff. mxh runs your customisations against every release and tells you which lines of that diff are yours." A diff is the list of differences between two versions of something, the same idea as a Git diff in Level 3.

mxH runs on your own machine, over an export of your Maximo. It needs Java 17 or newer and a folder. It installs nothing on the customer's Maximo and makes no network call during an assessment. The export is the system's structure, not its records: no work orders, no assets, no people. Security goes in as counts of users per group, never user names.

InputWhat it holdsWhy mxH needs it
Data dictionaryMAXOBJECT, MAXATTRIBUTE, MAXRELATIONSHIP and SYNONYMDOMAIN as CSV files (ALNDOMAIN too, if you use ALN domains)Your objects and fields, including the ones your team added, to compare with the target release
Customisation codeJava source and compiled JARs, and automation scripts (.py, .js)Every class, method and attribute your code names
Script launch pointsSCRIPTLAUNCHPOINT and LAUNCHPOINTVARS rowsWhat fires each script. A script whose code has not changed still breaks when the column its launch point binds to is gone
ScreensApplication Designer presentation XML, and MAF app.xml for role-based appsEvery field a screen binds, followed through its relationships
IntegrationsOSLC object-structure schemas or OpenAPI filesFields your object structures publish
ConfigurationEscalations, cron tasks, actions, workflows, communication templates, domains, properties, BIRT .rptdesign files, the Integrity Checker logConfiguration that names a column the target dropped
SecurityMAXGROUP, APPLICATIONAUTH, SECURITYRESTRICT, and group membership as countsWho each finding affects
Five ways a script starts. Five things can start an automation script. mxH reads the script's code and, when you send the launch points, what starts it. Watch the attribute trigger: if the field it watches is gone at the target, the script breaks without a single line of its code changing.

Five triggers each firing a script: a record being saved (object), a field changing (attribute), a button or workflow step (action), a message passing through integration (integration), and a condition being checked (custom condition).

All of this goes in one folder with a file called manifest.yaml at the top. The manifest names the customer, the release they run today, the add-ons installed, the export date, the target release, which inputs were supplied, and which were held back, with the reason. mxH checks the manifest before it does any work: a target that is not later than the source, or an input listed as both supplied and held back, stops the run with a message that names the field.

The other half of the comparison is IBM's side. mxH ships a release dictionary for each release it covers: the objects and attributes read from what IBM actually ships, plus IBM's upgrade scripts, relationships, screens, configuration and the compiled Java API. The counts below are read from the packs when the product is built, not typed by a person.

ReleaseObjectsAttributes
7.5.01,16119,386
7.6.1.11,64225,659
9.01,73926,927
9.11,82028,165
9.21,86628,942
9.3 (preview: IBM has not made MAS 9.3 generally available)1,86828,958

"Across versions" always means these releases and no others. For the classic levels IBM accepts as a starting point for the move to Manage (7.6.0.10, 7.6.1.2 and 7.6.1.3), mxH reads IBM's own upgrade scripts. In a full assessment the customer's own dictionary export is the source side, so 7.6.1.3 is compared as the customer actually runs it.

The four commands of an upgrade (from the mxH docs)

# Check Java, the jar, every pack's signature and the licence
mxh doctor

# 1. List what your package holds, before the real run
mxh assess --from ./kestrel --output ./round-0 --preflight

# 2. Run the assessment
mxh assess --from ./kestrel --output ./round-1

# 3. Fix, then rerun and compare with the first run
mxh assess --from ./kestrel --output ./round-2 --baseline ./round-1

# 4. After the upgrade, check every finding closed
mxh verify-closure --baseline ./round-2 \
  --export ./after-upgrade/dd --code ./after-upgrade/src \
  --customer "Kestrel Energy" --out ./closure
Way to run itYou supplyYou get
SnapshotYour release, the target and your add-ons. No export.Release-to-release findings from IBM's upgrade scripts, to size the work (--scripts-only)
Dictionary onlyThe dictionary aloneEvery length, type, required-flag and removed-attribute difference on your own columns
Full auditDictionary, code, screens and any configuration you includeFindings tied to your files and lines, with grade, evidence, owner and closure test

Remember: Start with what the customer can export this week. Every run says exactly what it was given, and the next run can add the rest.

Lesson 3

How findings are graded: BLOCKING, REVIEW, ENVIRONMENT and NOT ASSESSED

A finding is one difference that touches the customer's Maximo. mxH puts every finding in one of three grades, and states a fourth thing on every report. The grade answers one question: how much does this hurt?

mxH grades. Watch the findings drop into their buckets. BLOCKING: fix it before cutover. REVIEW: a person reads the code. ENVIRONMENT: check it on the target system itself. NOT ASSESSED is not a pile of findings; it is the line that says what the run was given and what it was not.

Findings drop into four buckets: BLOCKING (will not compile, load or run), REVIEW (depends on what the code does), ENVIRONMENT (a difference between the two systems) and NOT ASSESSED (stated on every report).

GrademxH's own meaningA real example from the Kestrel sample
BLOCKINGWill not compile, will not load, or throws on first use.PermitGate.java line 8 imports psdi.iface.jms.ErrorQueueNotfCronTask, which no longer exists in 9.1. The class cannot compile.
REVIEWA real difference whose consequence depends on what the code does with it.ASSET.ASSETHEALTH changed from INTEGER to DECIMAL. Whether it matters depends on who reads it.
ENVIRONMENTDiffers between the two systems; not a property of the release.WORKORDER.KEWELLID is the customer's own field. It is in their export and in neither IBM dictionary.
NOT ASSESSEDStated on every report, so a clean result's meaning is bounded.No launch points were supplied, so what fires each script was not checked, only what the script does.

Every finding also says how far it reaches into the customer's own work. Cited means a line, screen, row or grant names it. Referenced means something supplied works on that object. Inventory means the dictionary changed and nothing supplied goes near it. The comparison covers the whole dictionary; the reach sets the priority.

A grade on its own is not a plan. So every finding carries three more things: an owner (the role that fixes it, such as Customisation developer, Database / migration, or Application Designer / configuration), a required action, and a closure test. A closure test is a check anyone can run to prove the item is done, for example "the customisation compiles against the target's businessobjects.jar with no unresolved import". mxH also proposes one of five words for what to do.

ProposalMeans
RetainKeep it as it is; confirm it on the upgraded system
ChangeChange the cited code, screen or row before cutover
ReplaceReplace it with what the target ships for the same purpose
RetireRemove it; nothing supplied needs it on the target
InvestigateRead it against the target before deciding

The proposal is advice. A reviewer's decision, when the customer records one, is printed beside it, never over it. Related findings with a common owner are grouped into work packages, blocking first. A work package's acceptance test is the closure tests of the findings inside it.

The mistake: Call every difference a blocker, so the report looks serious. Do this instead: Keep BLOCKING for what will not compile, load or run. A REVIEW item needs a person to look, and most will be fine. Strong words are kept for findings that earn them, so the customer believes the ones that do.

Remember: Grade answers "how much does it hurt?". Owner, action and closure test answer "who fixes it, how, and how do we know?".

Lesson 4

Evidence classes A1 to C: what each one lets you say

The grade says how much a finding hurts. The evidence class says how much weight the finding will bear: what kind of proof sits under it, and therefore what sentence you are allowed to write about it. mxH keeps the two apart on every row. Its sample report puts it plainly: a blocking finding on weak evidence is a claim a customer can knock down, which is worse than not making it.

mxH evidence classes. Climb the ladder from the bottom. C is modelled behaviour. B2 is a difference seen in two dictionaries. B1 adds an IBM upgrade script that corroborates it. A3, A2 and A1 are confirmed by IBM's own registry, compiled API and upgrade scripts. The higher the rung, the stronger the sentence you may write.

A ladder of evidence strength: A1 stated by an IBM upgrade script, A2 confirmed in bytecode or API, A3 confirmed by the target registry, B1 dictionary observed and corroborated, B2 dictionary observed only, C modelled behaviour.

ClassEvidenceYou may sayYou may not conclude
A1IBM upgrade-script statedState it as what the release does, and name the script.Do not state it as an outcome without checking the target dictionary agrees.
A2Bytecode or API confirmedState that the type or member is gone at the target release.Do not call it gone without checking the target's own inheritance first.
A3Target registry confirmedState that the target does not accept it, and name the registry.Do not generalise from one registry to the product.
B1Dictionary observed and independently corroboratedState it as a release change, naming the dictionary difference and the corroborating script.Do not claim the script's specific values.
B2Dictionary observed onlySay "between these two dictionaries", and say which two.Never state it as a release change, and never as something IBM did.
CModelled behaviourAttribute it to the model and link the rule's evidence and its assumptions.Do not present it as measured, and do not imply coverage.

Here is each class on a real Kestrel finding. A1: ASSET.PLUSSGEOJSON is removed on the path to 9.2, stated by IBM's upgrade script for 9.0. A2: the Person methods are gone from IBM's compiled API at 8.7. B1: ASSET.GEOMETRY changed from BLOB to CLOB between the 7.6.1.3 and 9.2 dictionaries, and IBM's 9.0 upgrade script touches the same attribute, so the change is corroborated. B2: ASSET.ASSETHEALTH changed from INTEGER to DECIMAL between the 7.6.1.3 and 9.2 dictionaries, with no script saying so.

Why does B2 need such careful words? A dictionary dump is a picture of one system. A difference between two dumps may come from the release, or it may come from the add-ons installed on one side, such as Oil and Gas. So a B2 finding is stated as what it is: a difference between two named dictionaries. That is still useful. It is just not a statement about what IBM did.

Class C is modelled behaviour: mxH's local test harness models some of Maximo's business rules so a developer can test a customisation without a server. At 9.2 the model holds 50 rules over 24 objects, measured against IBM's own class signatures. A class C result is credited to the model, with its assumptions linked.

Ranks of evidence. The same idea you met in Level 11, one level up. IBM's own documentation and support pages sit at the top of the Assetize evidence pyramid. mxH's A classes rest on IBM's own shipped material: its upgrade scripts, its compiled API and its registries.

A pyramid of sources: IBM documentation and support at the top, recognised practitioners in the middle, general community posts at the bottom. A record card shows its sources with their ranks.

The mistake: "IBM changed ASSET.ASSETHEALTH to DECIMAL in 9.2." (A B2 finding written as if it were an IBM release change.) Do this instead: "Between the 7.6.1.3 and 9.2 dictionaries, ASSET.ASSETHEALTH changed from INTEGER to DECIMAL." Name both dictionaries. Then check stored values and any report or integration that carries the field.

Grade (severity)Evidence class (confidence)
  • How much it hurts
  • BLOCKING, REVIEW, ENVIRONMENT
  • Decides the order of work
  • Set by what the code does with the change
  • How much weight it bears
  • A1, A2, A3, B1, B2, C
  • Decides the wording you may use
  • Set by where the evidence came from

Remember: Before you quote a finding to a customer, read its class. The class tells you the exact sentence you are allowed to say.

Lesson 5

The Kestrel Energy sample, 7.6.1.3 to 9.2, read end to end

Kestrel Energy is a made-up oil and gas company. Its dictionary export, its Java, its automation script and its screen are synthetic. Everything it is compared against is real: IBM's 7.6.1.3 and 9.2 dictionaries, the Oil and Gas add-on columns, IBM's upgrade scripts and IBM's Java API index. It is the one approved sample, published in full at /mxh/sample, and it is the best way to learn to read an mxH report.

The runValue
Move7.6.1.3 to 9.2, with the Oil and Gas add-on on both sides
Export taken / assessed10 September 2026 / 5 October 2026
Produced bymxh 0.11.0, metadata pack 2026.09 (signed)
Objects in the export4: ASSET, FAILUREREPORT, LOCATIONS, WORKORDER
Files scanned3: PermitGate.java, KESHUTDOWN.py and the wotrack.xml screen
Shipped configuration compared8,841 entities, 422 differences, none named by the supplied code
Findings22: 1 BLOCKING, 13 REVIEW, 8 ENVIRONMENT
Evidence classes2 A1, 4 A2, 2 B1, 14 B2
Owners13 customisation developer, 8 database / migration, 1 Application Designer / configuration
Work packages8, blocking first
An upgrade, start to finish. The seven steps of an upgrade. mxH is step 2, find what breaks. Everything in this lesson happens there, and its output feeds steps 3 to 7.

A journey map in seven steps for a 7.6.1.3 to MAS 9.2 upgrade: understand the move, find what breaks with mxH, fix, build the pipeline with mxR, test, load the data with the Workbench, go live and prove it.

Read it in this order. First, the readiness report: it groups the work into must-fix-before-cutover items, each with what was found, why it matters, what to do, when it is done, the owner and when. For Kestrel it shows two must-fix items. One: a custom Java class needs rebuilding. MAS does not take a businessobjects folder on a server; custom classes ship in a customisation archive and must compile against the 9.2 classes. Two: the code calls Maximo methods that 9.x removed.

The one BLOCKING finding, field by field

grade:        BLOCKING
kind:         class-removed
evidence:     A2 · IBM's API at 9.1
message:      psdi.iface.jms.ErrorQueueNotfCronTask no longer exists in 9.1
              and your code references it
your code:    PermitGate.java:8
owner:        Customisation developer
action:       Replace the reference. The type does not exist at the target,
              so the customisation will not compile; find the supported
              equivalent or remove the dependency.
closed when:  The customisation compiles against the target's
              businessobjects.jar with no unresolved import.
proposed:     Replace
mxH grades. In the Kestrel run one finding lands in BLOCKING, thirteen in REVIEW and eight in ENVIRONMENT. Watch the BLOCKING bucket: one item, and it has an owner and a test that closes it.

Findings drop into four buckets: BLOCKING (will not compile, load or run), REVIEW (depends on what the code does), ENVIRONMENT (a difference between the two systems) and NOT ASSESSED (stated on every report).

Second, the REVIEW findings that reach the customer's own work: the three Person methods, two attributes removed on the way to 9.2 (ASSET.PLUSSGEOJSON and WORKORDER.PLUSSGEOJSON, stated by IBM's 9.0 upgrade script, with no supplied line using them), ASSET.ASSETHEALTH changing type and scale, ASSET.GEOMETRY changing from BLOB to CLOB and becoming non-persistent, and one screen field that is the customer's own column. Third, the ENVIRONMENT findings: eight KE fields, such as KEWELLID and KEPERMITSTATUS, that Kestrel added. An in-place upgrade carries them forward, so the proposal is Retain and the test is to confirm each one on the upgraded system.

Last, the Not assessed section. It is short and exact. Fourteen attribute references in the code could not be tied to an object, because the file names no object; the fix is to supply the launch-point export or add a line such as # mxh:object=WORKORDER. Launch points, configuration, security, object structures and a JAR inventory were not sent, and each line says what to export to cover it. A clean section then means exactly what was checked.

Work packageOwnerFindings
Class removedCustomisation developer1 BLOCKING, proposed Replace
Method removedCustomisation developer3 REVIEW, proposed Replace
Validate changed datatypes against actual usageCustomisation developer3 REVIEW, proposed Investigate
Attribute removed / Persistence changed / Scale changedCustomisation developer2 + 2 + 2 REVIEW, proposed Investigate
Screen field local extensionApplication Designer / configuration1 REVIEW, proposed Retain
Local extensionDatabase / migration8 ENVIRONMENT, proposed Retain

Remember: The suggested order is advice from the report: blocking packages first, then dictionary and migration work, then code, then configuration and screens, because a screen is tested against the column and class it will find on the target.

Lesson 6

One run, two readers: the engineer and the buyer

The person who pays for an upgrade and the person who does the work want different things from the same facts. The buyer is a sponsor, CIO or programme manager. They ask: how big is the job, what are we exposed to, what must happen first, who owns it, and how will I know it is done? The engineer is a developer, DBA or architect. They ask: which object, which attribute, which file and line, what is the evidence, and what test proves the fix?

The buyer readsThe engineer reads
  • The executive brief: the recommended next move and the work in scope
  • The readiness report: must-fix items with owners and dates
  • The programme view: work packages and acceptance tests
  • Counts of places that change, sorted by owner
  • The technical report: every finding with evidence, owner, action and closure test
  • The evidence appendix: the class and basis of each finding
  • findings.xlsx and assessment.json for tracking and tooling
  • preflight-db2.sql: read-only SQL listing data to review

Both come from one run, so they never disagree. The Kestrel brief opens with "Your upgrade. A clear way forward." and a recommended next move: proceed with upgrade planning, and resolve the named incompatible dependencies before keeping those functions at cutover. Then 22 observations organised into 8 work packages, and a sentence every buyer needs: a work package groups related decisions and tests; it is not an effort estimate.

File in the sampleWho it is forWhat it does
readiness.htmlEveryoneOpen this first: must fix, rewire for containers, retest, clean up, and your data and fields, each with an owner and a done-when
brief.htmlExecutive sponsorThe decision-ready summary
explorer.htmlEveryoneFrom the whole system down to what blocks the upgrade
report.htmlTechnical leadEvery finding with evidence, owner, action and closure
programme.html, architecture.html, engineering.html, assurance.htmlProgramme, architect, developers, assuranceThe same findings organised for each job
evidence.htmlReviewersWhat each finding was read from
findings.xlsx, assessment.json, assessment.mdDelivery team, developersTrack it, feed tools, diff one run against the next
mxh.lock.jsonAssuranceEvery input hashed, the pack digests and the run id
Which tool answers which question. Customer questions on the left, Assetize tools on the right. Follow the line from "what will break?". It lands on mxH. The question "what changes between the versions?" lands on Compare and the Upgrade Desk instead: that is IBM's side only.

Customer questions on the left connect to Assetize tools on the right: what changes in the upgrade to Compare and the Upgrade Desk, what an error means to Error lookup, what will break to mxH, how to ship safely to mxR, how to load a sheet to the Workbench, and anything else to ASK.

A report you can defend is a report you can repeat. mxH fingerprints every input in the lock file. Run it again on the same inputs and you get the same run id and byte-identical files. After fixes, rerun with --baseline pointing at the first run, and every earlier finding lands in one of seven outcomes: verified resolved, not reassessed, invalidated by evidence correction, no longer observed, changed, remaining, or newly observed. An input left out of the rerun is never counted as a fix: that finding shows as not reassessed.

After the move itself, verify-closure reads a fresh export of the upgraded system and marks each finding closed, not closed or not checked, with the lines it read. Keep the two words apart: a rerun compares two assessments before the move; closure checks the system after it. mxH also names the ladder a fix climbs: static analysis, harness run, target compile and link, target runtime, business acceptance. The Kestrel sample stands on the first rung, because it is a static assessment.

The mistake: Turn the finding count into days and print a cost on the report. Do this instead: Hand over counts with owners and closure tests. The customer's team or partner turns counts into days, using their own people, environments and change windows. mxH counts sites, not days, so nobody is held to a number made up from a count.

Remember: Same findings, different doors: the brief for the person who signs, the technical report for the person who fixes.

Lesson 7

From finding to fix in the Studio, and how to explain mxH

A finding is only useful when someone fixes it. Workbench 2.0, the Engineering Studio, is where that starts. On a finding in the sample assessment, press Open in Workbench 2.0. The Studio opens an upgrade project with the finding already loaded: the source and target versions, the object, the attribute, the owner, the required action, the closure test and the evidence. Nobody retypes anything.

  1. Open in Workbench 2.0
  2. Studio looks the object and attribute up at the target version
  3. Fix it in the right editor: Workflow, Reports, Scripts or Data
  4. Save and validate; each artifact records its proof levels
  5. Return evidence to MXH

From finding to returned evidence

Inside the project you pick the editor that fits the finding. A workflow condition that names a changed field opens in the Workflow Designer. A report that reads a removed column opens in Reports, which imports the .rptdesign and looks up every table and column at the target. A script opens in the Script Test Harness, which runs it against a mocked Mbo for the release you pick and gives a verdict per release: passes, breaks, or skipped where the release lacks an attribute the script reads. Your Maximo can also be captured into the project: the Studio reads the automation scripts, launch points, workflow processes and applications with GET requests only.

Proof levelMeans
StaticThe artifact is structurally compatible with the retained evidence
SimulatedThe browser engine exercised the Studio's model of the artifact
Target executionThe artifact ran on that Maximo build, and the result was kept

The levels are never merged. When you press Return evidence to MXH, the finding shows badges such as Remediation prepared and Static validation passed. The finding itself stays open until its own closure test passes. That is the rule that keeps an upgrade honest: preparing a fix and proving a fix are different events.

How each kind of change moves. Four lanes, four kinds of change. Kestrel's BLOCKING finding is in the Java lane: rebuild the class against the 9.2 libraries, put it in a customisation archive, and the Manage build picks it up. A screen fix would travel the configuration lane in a Migration Manager package instead.

Four lanes: configuration moves in Migration Manager packages, database structure moves in DBC scripts run by updatedb, Java moves in a customisation archive and a rebuild, and data moves in data loads.

Now the conversation you will have many times: explaining mxH to a customer. Lead with the problem they already feel. "You have to move off 7.6.1. IBM's regular support for 7.6.1.x ended on 30 September 2025, and Dual Support ends on 30 April 2027. IBM's product will work on 9.2. The budget goes on your own changes: the fields added years ago, the scripts, the Java, the screens. mxH finds those, counts them, and names an owner and a test for each, before you commit the budget."

  • What they send: three exports to start with: the data dictionary, the customisation source and the screen exports. Add launch points, configuration and security for a wider check.
  • What runs: mxH, on their side. It installs nothing on their Maximo and touches nothing in production.
  • What they get: a readiness report, an executive brief, a technical report, a workbook and the evidence for every finding, plus a rerun that proves progress.
  • What it costs: nothing. The tool and the metadata packs are free to use, with no key and no sign-up.
  • Who made it: Assetize. mxH is independent of IBM, and every A-class finding rests on IBM's own shipped material.

The mistake: Open the customer call with the list of things mxH was not given, and the caveats on each class. Do this instead: Open with the diff, the count and the owners. Show the sample. The Not assessed section and the evidence classes are there for the engineer who asks, and they make the count trustworthy.

Remember: Thirty-second version: "Your upgrade is a diff. mxH shows which lines of it are yours, who owns each one, and the test that proves it fixed."

Check yourself: the Level 12 quiz

18 questions. Pass mark 70%.

  1. What is mxH's hook line, the sentence its pages lead with?
    • Your Maximo upgrade is a diff
    • Maximo in the cloud, at last
    • Load your data faster
    • Ship Maximo like Maximo ships work
  2. Look at the picture. Which part does mxH report as the customer's upgrade work? (picture: Your upgrade is a diff)
    • Everything IBM changed between the two releases
    • Everything the customer ever customised
    • Only the overlap: IBM changes that touch the customer's own lines
    • Nothing until the upgrade is done
  3. Look at the buckets. A customer's Java imports psdi.iface.jms.ErrorQueueNotfCronTask, which no longer exists at 9.1. Where does the finding land? (picture: mxH grades)
    • BLOCKING
    • REVIEW
    • ENVIRONMENT
    • NOT ASSESSED
  4. PermitGate.java references IBM's Person class. Three of its methods were removed in 8.7, but no call to them is established. What grade is right?
    • BLOCKING, because a method is gone
    • REVIEW, because a class reference does not prove a call; reading the line settles it
    • ENVIRONMENT, because it is a customer class
    • No finding at all
  5. WORKORDER.KEWELLID is in Kestrel's export but in neither IBM dictionary. What is it, and what does mxH propose?
    • A removed IBM field: Retire it
    • The customer's own field, graded ENVIRONMENT: Retain it and confirm it on the upgraded system
    • A BLOCKING finding: Replace it
    • A typo in the export
  6. Why does every mxH report carry a NOT ASSESSED section?
    • To make the report longer
    • So a clean result means exactly what was checked, and each line says what to export to cover it
    • Because IBM requires it
    • To hide findings from the buyer
  7. Look at the ladder. The highlighted rung is B2, dictionary observed only. How may you state a B2 finding? (picture: mxH evidence classes)
    • As something IBM did in the release
    • As "between these two dictionaries", naming both
    • As a guaranteed failure on go-live
    • As modelled behaviour
  8. ASSET.GEOMETRY changed from BLOB to CLOB between the dictionaries, and IBM's 9.0 upgrade script touches the same attribute. Which evidence class is that?
    • A1
    • A2
    • B1
    • C
  9. Can a finding be BLOCKING and still rest on weaker evidence?
    • No, BLOCKING always means A1
    • Yes. Grade and evidence class are separate questions, so both are shown on every row
    • Only for ENVIRONMENT findings
    • Only in a snapshot run
  10. What does an mxH export contain?
    • Every work order and asset record
    • The system's structure: dictionary, code, screens, and optionally configuration and security counts
    • A copy of the production database
    • User names and passwords
  11. Which picture shows the way Kestrel's BLOCKING Java fix reaches MAS 9.2?
    • A Migration Manager package
    • A rebuilt class in a customisation archive
    • A data load
  12. Which releases does mxH ship dictionaries for?
    • Any Maximo version ever made
    • 7.5.0, 7.6.1.1, 9.0, 9.1 and 9.2, plus a 9.3 preview
    • Only 9.2
    • 8.x only
  13. You fixed the blocker and want to compare with the first run before the upgrade. Which command?
    • mxh verify-closure
    • mxh assess with --baseline pointing at the first run
    • mxh doctor
    • mxh export-sql
  14. Look at the journey. The highlighted step is where mxH runs. What do you hold at the end of it? (picture: An upgrade, start to finish)
    • A deployed release on PROD
    • A graded list of what breaks, each item with an owner, an action and a closure test
    • A loaded asset register
    • A signed IBM licence
  15. Look at the stack. Which layer did Kestrel's class-removed finding come from? (picture: The layers of change)
    • Configuration
    • Automation scripts
    • Integration and reports
    • Java
  16. A buyer asks how many days the upgrade will take. What does mxH give them?
    • A day rate and a total cost
    • Counts of the places that change, with owners and closure tests; their team or partner turns counts into days
    • A guess based on company size
    • IBM's estimate
  17. You press Open in Workbench 2.0 on a finding. What arrives in the Studio?
    • An empty project
    • The source and target versions, object, attribute, owner, required action, closure test and evidence
    • Only the finding's title
    • The customer's production data
  18. You return evidence from the Studio to mxH with "Static validation passed". Is the finding closed?
    • Yes, returning evidence closes it
    • No. It closes only when its own closure test passes; the badges show what was prepared
    • Only if a manager clicks Approve
    • Only for ENVIRONMENT findings

Remember it as a picture

  • Your upgrade is a diff: mxH reports only where IBM's changes between two releases touch the customer's own lines.
  • BLOCKING: Will not compile, will not load, or throws on first use. Fix before cutover.
  • REVIEW: A real difference whose consequence depends on what the code does with it. A person reads the line.
  • ENVIRONMENT: Differs between the two systems, not because of the release. Confirm it on the target itself.
  • NOT ASSESSED: Stated on every report, so a clean result means exactly what was checked.
  • A1: IBM upgrade-script stated: State it as what the release does, and name the script.
  • A2: bytecode or API confirmed: The type or member is gone at the target release. Check inheritance first.
  • A3: target registry confirmed: The target does not accept it; name the registry. Do not generalise to the product.
  • B1: dictionary observed and corroborated: A release change, naming the dictionary difference and the IBM script that corroborates it.
  • B2: dictionary observed only: Say "between these two dictionaries", and name both. Never "IBM changed".
  • C: modelled behaviour: Credit it to the model and link its assumptions. Never present it as measured.
  • Custom Java at upgrade: Rebuild against the target classes (Java 17 from 9.1; 9.2 supports Java 25) and ship it in a customisation archive.
  • mxH in the upgrade: Step 2, find what breaks: a graded fix list with owners and closure tests.
  • Why launch points matter: A script with unchanged code still breaks when the field its launch point watches is gone.

Where these facts come from

Try it on the real tools

How did Level 12 go?

Rate the level and say what worked, what did not, what you liked and what you did not. Send it now, or with your full report.