Assetize

Learning Lab

Level 14 · 15 levels · Final · about 70 minutes

Level 14 — Put it together: one upgrade, start to finish, and the final check

By the end: Walk a water company from Maximo 7.6.1.3 to MAS 9.2, naming the right practice and the right tool at every step, say what your own part as a developer is, and pass the final check at 80% or more.

One upgrade in seven steps: understand the move, find what breaks, fix, build the pipeline, test, load the data, go live and prove it. Every level you have passed is one of these steps.

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.

Lesson 1

The story, and step 1: understand the move

Every upgrade starts with facts you can check, not opinions. The first fact is the clock. IBM ended regular support for Maximo Asset Management 7.6.1.x on 30 September 2025. Customers who traded up to MAS can keep running 7.6.1.x under Dual Support until 30 April 2027. After that date, IBM says, EAM 7.6.1.x is no longer supported for Subscription Upgrade customers, and for Perpetual Trade-Up customers the usage rights expire and continued use would be out of compliance. On 1 November 2026, that is 180 days away.

The support clock. Find today's marker. Regular support for 7.6.1.x is already behind it. The next date, 30 April 2027, is the one Bluegum cannot move: the end of Dual Support.

A timeline: 30 September 2025 end of regular support for Maximo 7.6.1.x, 1 May 2026 MAS 8.x on Extended Support only, 30 April 2027 Dual Support ends, 1 July 2027 MAS 9.0 moves to Extended Support. A marker shows today.

The second fact is the route. This is not an in-place upgrade. IBM: "You must install Maximo Application Suite when you upgrade from Maximo Asset Management." You install MAS on Red Hat OpenShift, configure the database, deploy Manage, then migrate and verify. IBM accepts three classic levels as the starting point: 7.6.0.10, 7.6.1.2 or 7.6.1.3. Bluegum is on 7.6.1.3, so it starts from a level IBM names. Whether it goes straight to 9.2 or through an intermediate release is checked for its exact level on the Upgrade Desk.

Classic Maximo and MAS. Left: one application on WebSphere servers, the world Bluegum lives in today. Right: MAS in containers on OpenShift, with a core for users and licences and Manage running as pods. The upgrade is a move from one picture to the other.

On the left, Maximo 7.6.1 runs as one application on WebSphere servers. On the right, Maximo Application Suite runs in containers on Red Hat OpenShift: a core for users and licences, and applications such as Manage, Monitor, Health, Predict and Visual Inspection, each as pods.

Two Assetize tools answer step 1. Compare (assetize.com.au/compare/7-6-1-3/9-2) lists what IBM changed between the two versions, area by area: 190 changes to absorb across 22 functional areas, with 160 fixes and 1,323 new-capability announcements reported for context only. The Upgrade Desk (assetize.com.au/upgrade/7-6-1/9-2) puts the move on one page: the clock, the route, what IBM says about platform, database, Java, users and add-ons, each with IBM's own words and page, then a phased checklist.

What IBM says about the moveWhat it means for Bluegum
"Run the Integrity Checker utility to check for database errors before you start the upgrade process."Run it on a production copy first, and again after the migration
"You prepare connectors and migrate customizations by using customization archives."The 3 Java classes travel in a customisation archive, not a server folder
Manage 9.1 runs on Java 17: "recompile customization archives". Manage 9.2 supports Java 25.Plan a recompile and a test pass for the Java
User and group management APIs deprecated in 9.1 are removed in 9.2.Any script that creates users the old way is rewritten
RMI is not supported in Maximo Manage; REST is used instead.Any integration calling in over RMI is rebuilt on REST
Work Centers and Anywhere Mobile are removed from MAS from 8.9.Field crews move to Maximo Mobile: a workstream of its own
Manage 9.2 supports BIRT 4.21.Re-run every customised report on the target

The Upgrade Desk's checklist for 7.6.1 to 9.2 has items before, during and after the move. Some are cited from IBM's pages. Others are marked as specific to your system, because only Bluegum's own Maximo can answer them: the exact fix level, every automation script by launch-point type, every endpoint address, AppPoint use per user type. Those questions are the bridge to step 2.

An upgrade, start to finish. Step 1 lights up. You leave it with the dates, the route and the list of what IBM changed. You do not yet know which of those changes touch Bluegum's own work.

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.

Remember: Step 1 answers "what changes, and by when?". It does not answer "what breaks for us?". That is step 2.

Lesson 2

Step 2: find what breaks with mxH

Compare listed 190 changes. Bluegum does not need all 190. It needs the ones that touch its 40 scripts, 3 classes, screens and integrations. That is what mxH is for: "Your Maximo upgrade is a diff. mxh runs your customisations against every release and tells you which lines of that diff are yours."

Your upgrade is a diff. IBM's change on the left, Bluegum's own work on the right. The overlap is the upgrade work. Everything outside it is IBM's job.

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 run starts small. Week one, before anyone has exported anything, a snapshot run (mxh assess with --scripts-only) reads IBM's upgrade scripts for the move and sizes the work. Week two, Bluegum's DBA runs the read-only SELECTs that mxh export-sql prints, and the team zips the scripts, the Java source and the Application Designer screen exports. The manifest names the customer, 7.6.1.3, the target 9.2, the export date, and what was held back. mxH runs on Bluegum's own machine and installs nothing on their Maximo.

  1. Snapshot from IBM's scripts
  2. Export dictionary, code and screens
  3. mxh assess with the manifest
  4. Readiness report and brief
  5. Work packages by owner

Step 2 in practice

Read the report the way you learned in Level 12. Start with the readiness report: what must be fixed before cutover, each item with an owner and a done-when. Then the findings by grade. BLOCKING items will not compile, load or run, and go first. REVIEW items need a developer to read a line; most will be fine. ENVIRONMENT items are differences between the two systems, such as Bluegum's own fields, which an in-place upgrade carries forward and someone confirms on the target. The Not assessed section says exactly what the run was not given, and what to export to cover it next time.

mxH grades. The BLOCKING bucket is the cutover list. Watch which findings land there: classes that will not compile against 9.2, and calls to members IBM removed once a call is proven.

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).

Each finding carries an evidence class, and that decides how you talk about it. A finding stated by an IBM upgrade script (A1) can be described as what the release does. A finding seen only by comparing two dictionaries (B2) is described as "between these two dictionaries", naming both, never as something IBM did. Bluegum's board gets the executive brief: the recommended next move, the work packages, and counts of places that change. The developers get the technical report, the workbook and the evidence appendix. Both come from one run.

Compare and the Upgrade Desk (step 1)mxH (step 2)
  • What IBM changed between two versions
  • The same for every customer
  • Dates, route, IBM's words and pages
  • Answers: what changes, and by when?
  • Which of IBM's changes touch this customer
  • Different for every customer
  • Findings tied to their files and lines
  • Answers: what breaks for us, and who fixes it?

The mistake: Turn the 190 changes from Compare into a project plan, and give every developer a share to check. Do this instead: Run mxH on the customer's own export. Plan from the findings that touch their work, each with an owner and a closure test.

Remember: Step 2 ends when every BLOCKING and REVIEW finding has an owner, and every Not assessed line has a decision: export it, or accept the gap in writing.

Lesson 3

Step 3: fix it, in the Studio and the Script Test Harness

Fixing starts from the finding, not from a blank page. On a finding in the assessment, Open in Workbench 2.0 starts a Studio project with the source and target versions, the object, the attribute, the owner, the required action, the closure test and the evidence already loaded. The developer opens the editor that fits the finding: Workflow for a workflow condition, Reports for a .rptdesign, Scripts for an automation script, Data for a sheet.

The layers of change. Scripts sit above Java in the stack: lighter to change and lighter to upgrade. When a fix can be a script, it is a script.

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.

The automation scripts come first, because there are 40 of them and each is quick to test. The Script Test Harness runs a launch-point script against a mocked Mbo for the release you pick, and gives a verdict for each release: passes, breaks, or skipped where the release lacks an attribute the script reads. A script that reads a field IBM removed shows up as breaking on 9.2 before it ever reaches a real server. The same tests later run in the pipeline.

A completion gate in action. One of Bluegum's 40 scripts: a completion gate on WORKORDER. With the failure code missing, the save is stopped with a message. Testing it on the 9.2 stub proves the rule still holds on the new release.

A technician sets a work order to COMP with no failure code. The save triggers the automation script, the script raises an error, and the save is stopped with a message. With a failure code filled in, the save goes through.

The 3 Java classes are next. MAS does not take a businessobjects folder on a server. Each class is recompiled against the 9.2 Manage libraries (Manage runs on Java 17 from 9.1, and 9.2 supports Java 25), checked that its parent classes and methods still exist, and packed into a customisation archive that the Manage workspace references. If a class only did what a script can do, the better fix is to retire the class and write the script.

Then the integrations. Bluegum's finance interface logs in with maxauth, a user name and password encoded in base64 in a header. MAS uses API keys for programs: a key created for one Maximo user, sent in the apikey header, and every call runs with that user's security. Each external system gets its own integration user, the right security groups, its key in a secrets store, and a test call before cutover. The GIS link used RMI, which Manage does not support, so it is rebuilt on the REST API.

The login change. The MAS door. The old maxauth caller bounces with 401; the API key opens it. Every one of Bluegum's 12 integrations is tested at this door before go-live.

Two doors. The 7.6.1 door accepts a maxauth user and password and an API key. The MAS 9 door accepts only the API key; the maxauth caller bounces with 401.

Bluegum findsFix it withProven by
A script reads an attribute removed on the way to 9.2Script edit in the Studio, tested in the Script Test HarnessThe harness verdict on the 9.2 release
A Java class imports a class gone at 9.1Replace the reference, recompile, customisation archiveCompiles against the target's businessobjects.jar
A report reads a changed columnReports in the Studio: import the .rptdesign, check columns at 9.2The report runs on 9.2 and returns the baseline rows
An integration sends maxauthIntegration user plus API keyA test call answers 200
Field crews on AnywhereMaximo Mobile, planned per roleA Technician journey on a device

When a fix is prepared, Return evidence to MXH sends it back with the proof levels it passed. The finding stays open until its own closure test passes. Preparing a fix and proving it are different events, and the report keeps them apart.

The mistake: Fix the Java first because it looks scariest, and leave the scripts for later. Do this instead: Fix in the order mxH suggests: blocking packages first, then dictionary and migration work, then code, then configuration and screens. Within code, prefer a script over Java whenever a script can do the job.

Remember: Every fix gets a test before it gets a deploy. The harness and the stub make that test cheap.

Lesson 4

Steps 4 and 5: ship it with mxR, and test it all the way

Bluegum now has dozens of fixes. Each one has to reach DEV, then TEST, then PROD, in the same form, with tests at every stop. Copying files by hand at 8 pm is how 7.6.1 changes used to go in, and it is how mistakes get in. mxR ships Maximo changes the way Maximo ships work: every change is a work order.

An mxR work order moves site to site. Watch one work order travel. WAPPR, APPR, INPRG and COMP on DEV, then the same work order and the same commit started on TEST, then PROD. Nothing is rebuilt between sites.

An mxR change work order goes WAPPR, APPR, INPRG and COMP on DEV, then the same work order and commit move to TEST and then PROD. Failure sends it to CAN with a failure code.

mxr plan reads the Git diff and raises the work order in WAPPR. The path rule decides how heavy the deploy is: anything under hot/, tests/ or jobplans/ is HOT (applied through REST in minutes); a change to the site file's cr: overlay, such as JVM options or JMS, is a RESTART; anything under archive/, where Bluegum's three Java classes live, is a REBUILD. mxr approve moves it to APPR and records who approved. Approval is required for PROD and for every REBUILD, and a REBUILD carries a backup reference and a window before it is approved.

The path rule sorts every change. Drop Bluegum's Java fix into the sorter. A path under archive/ lands in REBUILD, and the card asks for a backup reference and a window.

Changed file paths drop into three bins: hot/ and tests/ go to HOT, site file settings go to RESTART, archive/ and build settings go to REBUILD. REBUILD carries a backup reference and a window.

mxr start moves the work order to INPRG: it deploys for the tier, then runs the job plan, an ordered list of tests with On, Gate and Test switches. lint compiles the Jython on the site's own interpreter. api runs Playwright request tests on a test site. scripts-fn calls each script endpoint with its tests. mif posts to the enterprise service and checks the message tracking tables. ui runs browser journeys such as Work Order Tracking. golden opens every screen the push touched and checks its title, controls, toolbar, tabs and Select Action entries against a captured baseline. When every gated task passes, the work order goes to COMP. When a gated task fails, the work order holds in INPRG so the team can fix and resume; if they stop instead, mxr cancel sends it to CAN with one failure code, such as TEST/GATE, and fills in the runbook for that code.

A pipeline with gates. A pipeline with gates: build, unit tests, deploy to DEV, integration and UI tests, approval, TEST, PROD and a smoke test. Watch the change stop at the integration stage when a test fails. That is the gate doing its job.

A change flows through build, unit tests, deploy to DEV, integration and UI tests, approval, deploy to TEST then PROD and a smoke test. Each stage turns green in turn.

This is continuous testing from Level 10: tests at every stage, and a failing test stops the change. The shape of the tests follows the pyramid from Level 9: many fast unit tests on the scripts, fewer integration tests against the API and the Integration Framework, and a few slow browser journeys on the screens people use most. Bluegum also tests the bad day on purpose: an integration that gets 429 backs off and retries; a queue with a bad message stops or sets it aside the way its type says; a load that drops halfway retries only the failed rows.

The test pyramid. Many unit tests at the base, a few UI journeys at the top. Bluegum's 40 scripts each get unit tests; its 12 integrations get integration tests; its five busiest screens get journeys.

A pyramid with many fast unit tests at the base, fewer integration tests in the middle and a few slow UI tests at the top. A speed meter beside each layer.

TestWhat it proves for BluegumWhere it runs
Unit tests on scriptsThe rule still holds at 9.2Script Test Harness and the stub, every commit
API testsCreate, change and read work orders through MXAPIWODETAILmxR api task on the test site
Integration testsFinance and GIS messages go in and outmxR mif task
UI journeys and golden screensPlanners and supervisors can still do their jobmxR ui and golden tasks
Smoke testThe system is alive after each deploymxR smoke task

The mistake: Test everything by hand on PROD the night before go-live. Do this instead: Put the tests in the job plan, run them on every site the change touches, and let a failing gate stop the change before PROD.

Remember: In mxR, the work order is the record of what was shipped, where, when, by whom and with which tests.

Lesson 5

Steps 6 and 7: load the data, go live, and prove it

The upgrade carries Bluegum's existing records forward. But every go-live also loads data: the new treatment plant's 600 assets, cleaned-up location hierarchies, a fresh set of PMs and job plans, and the meter readings gathered while the system was being moved. All of it goes through the Data Workbench and Workbench 3, never through SQL.

A data load you can prove. The load as Bluegum runs it: connect to the MAS 9.2 test system, pick the object structure, map the sheet, check and fix, preview every change, load, read each row's result, reconcile.

A spreadsheet becomes a load in steps: add your Maximo, pick the object structure, map columns, run the checks and one-click fixes, preview every create, change and delete, load, read each row's result, and reconcile against Maximo.

The loads are grouped into a campaign: organisations and sites first, then locations, then assets, then job plans, then the PMs that use them. Bluegum rehearses the campaign three times on a production-sized copy. Rehearsal one finds 300 locations whose parent codes were spelled two ways. Rehearsal two runs clean in nine hours, so the cutover window is booked for twelve. The cutover packages require approval, so each runs only once its exact plan is approved.

Cutover weekend follows a written plan. Friday evening: configuration freeze, integrations paused, the JMS queues drained and the cron tasks that read them stopped in the right order. The migration runs. The Integrity Checker runs again on the new system; IBM's support notes report that it can show errors after an EAM to Manage upgrade, so the run is scheduled, not optional. mxR's smoke tasks check each bundle is alive. The campaign loads. Every row has a result; failed rows are retried, and committed rows are sent once.

Reconcile: prove what landed. Sunday 5 a.m. The rows Bluegum meant to load sit beside the records read back from Maximo. Matching rows tick green; the one flagged row names the field that differs, and the team explains it before the data owner signs.

The rows you meant to load sit next to the records read back from Maximo. Matching rows tick green; one row that differs is flagged amber, with the field that differs.

Then the proof. Go or no-go is decided by criteria written down in advance, with the smoke tests that decide them. After go-live, mxH verify-closure reads a fresh export of the upgraded system and marks every finding closed, not closed or not checked, with the lines it read. Every customised BIRT report runs on 9.2 and returns the same rows as the baseline. Cron tasks, escalations and queues are running, with nothing stuck in an error queue. The classic 7.6.1.3 system is retired before 30 April 2027.

From DEV to PROD. Production is the last gate. The change package reaches PROD only after the check and the sign-off at every gate before it.

A change package moves from DEV to TEST to PRE-PROD to PROD. At each gate a check runs and someone signs off before it moves on.

ProofComes fromWho reads it
Every planned change shipped and testedmxR work orders at COMP, with their job plansChange board, auditors
Every upgrade finding closedmxH verify-closureProgramme manager, sponsor
Every loaded row landed as meantWorkbench reconcileData owner
The system is alive and users can workSmoke tests, UI journeys, golden screensOperations, the business

The mistake: Call it done when the last load finishes without errors. Do this instead: Call it done when you can prove it: findings closed, rows reconciled, tests green, and the old system's retirement on the calendar.

Remember: Go-live is a decision taken on written criteria. Proof is what lets the business trust that decision.

Lesson 6

Your part in it, and how to take the final check

On a project like Bluegum's you will not run the whole upgrade on your first day. You will own pieces of it, and each piece uses something you learned in this lab. You might fix one of the 40 scripts and write its unit tests. You might add a golden-screen task to an mxR job plan. You might improve a Workbench check so that the misspelled parent codes are caught in seconds instead of in a rehearsal. You might add a record to Assetize so the next customer finds the answer on the first search.

Which tool answers which question. Questions on the left, tools on the right. When a customer asks you something, this is the map in your head: changes and deadlines to Compare and the Upgrade Desk, what breaks to mxH, shipping to mxR, loading to the Workbench, anything else to ASK.

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.

When someone asks you…You reach for…Level
"What changes between 7.6.1.3 and 9.2?"Compare and the Upgrade Desk6 and 11
"When does our support end?"The upgrade deadlines, with IBM's pages6
"Which of our scripts break?"mxH12
"Does this script still work on 9.2?"The Script Test Harness and the stub8 and 9
"How do we ship this safely to PROD?"mxR: a work order, a tier, a job plan10
"How do we load this sheet and prove it?"The Data Workbench and Workbench 313
"What does BMXAA4195E mean?"Error lookup and ASK5 and 11

The habits matter more than the tools. Read before you build: find what already exists. Ask "which version?" and "where is the evidence?" before you trust any answer, including your own. Make small changes, with tests, through a pull request. Test the bad day, not only the good one. Never write to a Maximo database with SQL, and never commit a secret. When a check fails in front of you, fix it, even if your change did not cause it, then say what you fixed.

Six principles. Six principles, six pictures. Fail closed: when unsure, the gate shuts. That is how mxR treats a failing test, how the Workbench treats an unconfirmed delete, and how mxH treats an input it was not given.

Six cards, each with a picture: KISS, DRY (one source feeding many places), YAGNI, single responsibility, fail closed (a gate that shuts when unsure) and idempotent (pressing twice gives one result).

  • Keep it simple: one job per page, one source for each fact.
  • Show strength first: what the product found and does, then the evidence, then the next step.
  • Write in short sentences. Say "your Maximo". Explain every term the first time.
  • AI helps at build time; answers at run time come from typed facts and ranked records.
  • Truth stays in the internal records; customers see what works and how to adopt it.
AI at build time, facts at run time. The line that runs through everything Assetize builds. AI helps read sources and shape records at build time. At run time, the answer is built from checked facts and ranked records; no model decides it.

At build time, AI helps read sources and shape records, and every record is checked and stored with its sources. At run time, the answer is built from typed facts and ranked records that already exist; no AI model decides it.

The final check has 30 questions from every level, many of them pictures you have met before. The pass mark is 80%: 24 or more right. Read each picture before you read the options; the picture usually holds the answer. When you pass, send your results and your feedback from the report page. Tell us what worked and what did not. The lab gets better because people say so.

The mistake: Rush the picture questions because they look easy. Do this instead: Look at what the picture shows: which status the token is on, which bucket is lit, which door the caller stands at. Then pick the option that matches it.

Remember: You have learned the whole job, one level at a time. Now prove it: 80% or more, then send your feedback.

Real practice on the Maximo SIM

Tasks you do by hand on the training Maximo, with the evidence your trainer checks.

  1. A small release, start to finish (UAT). Everything at once: a change built in DEV, tested, moved to UAT, data loaded, and proof written down.

The final check

30 questions. Pass mark 80%.

  1. Look at the map. What do the free tools, ASK and the three products all draw from? (picture: Assetize in one picture)
    • A live AI model
    • The evidence base of source-backed records
    • The customer's production database
    • A forum
  2. Look at the codes. Which one means "Maximo knows who you are, but your user is not allowed to do this"? (picture: Status code families)
    • 401
    • 403
    • 404
    • 500
  3. An integration gets 429 Too Many Requests. Which picture shows good code?
    • Retries at once, again and again
    • Waits, then retries, waiting longer each time
  4. Look at the token. What is true about this work order? (picture: The work order lifecycle)
    • It is waiting for approval
    • The work is in progress
    • It is closed and can no longer change
    • It was cancelled
  5. Look at the shelf: 14 items, 2 of them reserved for other work orders. What is the available balance? (picture: Current balance and available balance)
    • 14
    • 12
    • 2
    • 16
  6. Look at the graph. What must happen at the highlighted step before the branch joins main? (picture: Branch, commit, pull request, merge)
    • Nothing, merge straight away
    • The checks pass and a reviewer approves the pull request
    • The branch is deleted
    • The change is deployed to PROD
  7. You notice an API key in a commit you pushed an hour ago. What do you do?
    • Delete the commit and say nothing
    • Tell someone straight away and get the key replaced; assume it has been seen
    • Leave it, nobody reads Git
    • Rename the file
  8. Bluegum's DBA offers to fix 20,000 asset descriptions with one SQL UPDATE. Look at the picture. What is wrong? (picture: Every change goes through the rules)
    • Nothing, SQL is faster
    • It skips the business rules, audit and record versions; load through the object structures instead
    • SQL cannot change text
    • Assets have no descriptions
  9. Look at the picture. A customer shows AWAITPARTS on screen. Why should a script compare against the internal value instead of the word on screen? (picture: Synonym domains)
    • The business rules act on the internal value; the screen word can differ from customer to customer
    • AWAITPARTS is too long for a script
    • Scripts cannot read text values
    • The internal value is faster to type
  10. Which REST query setting makes Maximo filter the records before it sends them?
    • oslc.select
    • oslc.where
    • oslc.pageSize
    • lean
  11. You need to approve a work order through the API so Maximo's status rules run. Look at the four verbs. Which call fits? (picture: The verbs on a record)
    • A PATCH that writes the STATUS field like any other field
    • An action call such as changeStatus
    • A DELETE of the old record, then a new POST
    • A GET with oslc.where=status="APPR"
  12. Look at the timeline. Bluegum traded up to MAS and still runs 7.6.1.3 beside it. Which date can it not move past on classic? (picture: The support clock)
    • 30 September 2025
    • 30 April 2027
    • 1 July 2027
    • There is no date
  13. Look at the door. Bluegum's finance integration sends maxauth to the new MAS 9.2 system. What happens, and what is the fix? (picture: The login change)
    • 200, nothing to do
    • 401; give the integration its own user and an API key
    • 500; restart the server
    • 404; rename the object structure
  14. A changed escalation and a new domain value must move from DEV to TEST. Which picture shows the right lane?
    • Migration Manager package
    • DBC script run by updatedb
    • Customisation archive and rebuild
    • A data load
  15. A rule must run every time a work order is saved. Look at the stack. What do you build first? (picture: The layers of change)
    • A Java class that extends the work order business object
    • An automation script with an object launch point
    • A DBC script that adds a database trigger
    • A BIRT report that lists the bad saves
  16. A completion-gate script sits on WORKORDER. Look at the picture: a technician sets COMP with no failure code. What happens? (picture: A completion gate in action)
    • The save goes through
    • The script raises an error and the save is stopped with a message
    • The work order is deleted
    • The status jumps to CLOSE
  17. Look at this queue. A bad message arrives. What happens to the messages behind it? (picture: Sequential and continuous queues)
    • They are processed in parallel and the bad one is set aside
    • They wait: a sequential queue keeps order and stops at the bad message
    • They are deleted
    • They go to the publish channel
  18. Which Integration Framework part receives data into Maximo from another system?
    • Publish channel
    • Enterprise service
    • Cron task
    • Domain
  19. Look at the pyramid. Where should most of Bluegum's tests sit? (picture: The test pyramid)
    • At the top: many slow UI tests
    • At the base: many fast unit tests
    • In the middle only
    • Nowhere: test by hand
  20. Look at the sorter. Bluegum's Java fix changes a file under archive/. Which tier, and what must the work order carry before approval? (picture: The path rule sorts every change)
    • HOT, nothing extra
    • RESTART, a new API key
    • REBUILD, a backup reference and a window
    • No tier, it is skipped
  21. Look at the picture. The fix passed every gate on DEV. How does mxR promote it to TEST? (picture: An mxR work order moves site to site)
    • A new work order with a rebuilt package
    • The same work order and the same commit, started on TEST
    • Copy the files by hand
    • Email the TEST administrator
  22. Bluegum's change board wants every passing change ready, with a person pressing release for PROD. Which practice is that?
    • Continuous integration
    • Continuous delivery
    • Continuous deployment
  23. An IBM support page and a forum post disagree. Look at the pyramid. Which ranks higher in Assetize? (picture: Ranks of evidence)
    • The forum post, it is newer
    • The IBM support page
    • Neither, average them
    • Whichever has more likes
  24. Look at the picture. When ASK answers a question on the live site, what produces the answer? (picture: AI at build time, facts at run time)
    • A call to an AI model
    • Typed facts and ranked records that already exist; no AI model decides it
    • A person typing replies
    • A random record
  25. Look at the ladder. The highlighted class is B2. How do you word a B2 finding to a customer? (picture: mxH evidence classes)
    • "IBM changed this in 9.2"
    • "Between these two dictionaries", naming both
    • "This will fail on go-live"
    • "Our model predicts this"
  26. Bluegum asks which of its own scripts, classes and screens break on 9.2. Which product answers?
    • Compare
    • mxH
    • mxR
    • The Workbench
  27. Bluegum updates 1,500 PM descriptions with a sheet that carries no child rows. Which picture shows the action that leaves everything else alone?
    • AddChange
    • Sync
    • Delete
  28. The cutover load finished with every row green. Look at the picture. What proves the register is right? (picture: Reconcile: prove what landed)
    • The green results are enough
    • Reconcile: read the records back from Maximo and compare them with what you meant to load
    • Ask the users on Monday
    • Load it again to be sure
  29. Look at the journey. The highlighted step builds the pipeline. In the tool used there, what is every change? (picture: An upgrade, start to finish)
    • A pull request comment
    • A work order with Maximo's own statuses, worked one site at a time
    • A row in a spreadsheet
    • An email to the change board
  30. A test fails in front of you, and your change did not cause it. What is the house rule?
    • Ignore it, it is not yours
    • Fix it, run the check again, then say what you fixed
    • Delete the test
    • Wait until someone else notices

Remember it as a picture

  • Step 1: understand the move: Compare and the Upgrade Desk: what IBM changed, the dates, the route and the checklist.
  • Step 2: find what breaks: mxH: which of IBM's changes touch the customer's own lines, with owners and closure tests.
  • Step 3: fix: Open the finding in the Studio; test scripts in the Script Test Harness; scripts before Java.
  • Step 4: build the pipeline: mxR: every change a work order, a tier from the path rule, DEV then TEST then PROD.
  • Step 5: test: Unit, API, integration, UI and golden screens in the job plan; a failing gate stops the change.
  • Step 6: load the data: A Workbench campaign, rehearsed until it is boring, cut over after approval.
  • Step 7: go live and prove it: Smoke tests, reconcile, verify-closure, sign-off, and the classic system retired.
  • The clock: 7.6.1.x regular support ended 30 September 2025; Dual Support ends 30 April 2027.
  • Classic to Manage: A MAS install plus a migration, not an in-place upgrade. Integrity Checker first.
  • Logins at MAS: Programs use an API key for their own integration user; maxauth gets 401.
  • REBUILD: A change under archive/: backup reference and window before approval.
  • Cutover: PROD is the last gate: written go or no-go criteria, then sign-off on the proof.

Where these facts come from

Try it on the real tools

How did Level 14 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.