Learning Lab · Picture library
Every picture in the lab, in one place.
Pictures stick. Every animated diagram the levels use, to replay and revise before the final check.
Foundations
- The asset management cycle. A loop of six steps: an asset breaks or falls due, a work order is raised, it is approved and planned, a technician does the work, parts and hours are recorded, and the history feeds the next plan. A highlight travels round the loop.
- Assetize in one picture. IBM documentation and other sources flow into the Assetize evidence base of source-backed records. From it come the free tools and ASK, and three products: mxH for upgrades, mxR for shipping changes and the Data Workbench for loading data, each pointing at a customer Maximo.
- Who uses Maximo. Maximo in the middle, with seven people around it: planner, supervisor, technician with a phone, storeroom clerk, buyer, reliability engineer and administrator, each with one line on what they do.
- A request and a response. A laptop sends a request (method, address, headers, body) across to a server. The server answers with a status code and a body. The packet travels there and back.
- Status code families. Three lanes: 2xx success in green (200 OK, 201 Created), 4xx your request needs changing in amber (400, 401, 403, 404, 429), 5xx server problem in red (500, 503). Each code has a small picture.
- JSON as text and as a tree. A Maximo JSON answer shown as text on the left and as a tree on the right: member is a list holding two work orders, each with wonum and status. Brackets light up as their tree nodes do.
- The parts of a curl command. One curl command with each part labelled in turn: the program curl, -H and the apikey header, the address, the object structure name, and the query settings after the question mark.
- No key, no data. A request walks up to a locked Maximo door. Without a key it bounces back with 401. A valid key for a user without permission gets past the door and stops at the security gate with 403. A good key with the right access gets 200 and the records.
- Branch, commit, pull request, merge. A Git graph: the main line, a branch splitting off, two commits on it, a pull request with tests and a review tick, then the branch merging back into main.
- A pull request up close. A pull request card: the title, a diff with red removed lines and green added lines, checks turning from running to passed, and a reviewer approving.
- Small change versus big change. Two pull requests side by side. The small one, twelve lines, is reviewed and merged in minutes. The big one, two thousand lines, hides a bug that slips through and breaks later.
- Six principles. 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).
- Safe to press twice. A request is sent, the network drops the answer, and it is sent again. On the left, without protection, two records are created. On the right, with an idempotent request, there is still one record.
- Where secrets live. An API key typed into code is committed, pushed and copied to clones, build logs and forks. Deleting it in a new commit leaves it in the old one, so the key is rotated. On the safe side the code holds only the name, the value sits in a secret store, only the running program reads it and logs mask it.
Practitioner
- Assets live in locations. A site contains a building, which contains a plant room, which contains locations. A pump asset sits in one location, then moves to another, and its history moves with it.
- The work order lifecycle. A work order status machine: WAPPR to APPR to INPRG to COMP to CLOSE, with WSCH and WMATL as side statuses and dashed arrows to CAN from WAPPR and APPR. A token moves along allowed arrows. Once the work order is in progress, an attempt to cancel it is refused and shakes red, and the allowed moves are listed: WAPPR, WMATL, COMP, CLOSE.
- A PM makes work on a schedule. A preventive maintenance record with a frequency drops a new work order onto a calendar each time it falls due. The next due date moves forward after each one.
- A job plan stamps out the work. A job plan template with tasks, labour and materials is applied to a new work order, and the tasks, labour and materials copy onto it.
- Current balance and available balance. A storeroom shelf with items. Some are tagged as reserved for other work orders. Current balance counts every item on the shelf; available balance counts only the untagged ones.
- From request to shelf. A purchase requisition becomes a purchase order to a vendor, the goods are received into the storeroom, the invoice is matched and the stock balance goes up.
- Every change goes through the rules. Screens, the REST API and integrations all send changes through the MBO business rules layer, which checks them before they reach the database. A direct SQL arrow that tries to skip the rules is blocked with a red cross.
- An object and its attributes. The WORKORDER object drawn as a card of attributes: WONUM, DESCRIPTION, STATUS, ASSETNUM, LOCATION, SITEID, WORKTYPE. STATUS opens a list of allowed values from its domain, WOSTATUS.
- Synonym domains. A customer value such as AWAITPARTS maps to Maximo's internal value WMATL. The screen shows the customer's word; the business rules use the internal value.
- Organisations and sites. An organisation holds two sites. Work orders, assets and locations belong to one site. A user with access to only one site sees that site's records; the other site's records are greyed out.
- An object structure bundles objects. The MXAPIWODETAIL object structure drawn as a box holding WORKORDER with its children: tasks (WOACTIVITY), planned labour (WPLABOR) and planned materials (WPMATERIAL). An API call reads the whole bundle in one answer.
- Build a REST query. An interactive query builder: tick fields to select, pick a status to filter on and a page size. The address builds itself as you click, and a small result table changes to match.
- The verbs on a record. A work order record card with four actions around it: GET reads it, POST creates a new one, POST with x-method-override PATCH changes it, and an action call such as changeStatus runs business logic.
- Reading a Maximo error. A Maximo error answer with its parts labelled: the HTTP status 400, the reason code starting with BMXAA, the message in words, and the extended error link.
- Classic Maximo and MAS. 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.
- How an operator keeps MAS running. A configuration file (the ManageWorkspace custom resource) says what should be running. The operator compares it with what is running and changes the pods until they match, then keeps watching.
- The login change. 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.
- The support clock. 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 layers of change. 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.
- From DEV to PROD. 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.
- How each kind of change moves. 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.
- Five ways a script starts. 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).
- A completion gate in action. 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 Integration Framework. An ERP and a GIS on the left, Maximo on the right. Every lane passes through an object structure. Messages come in through an enterprise service and its inbound queue, and go out through a publish channel and its outbound queue to an endpoint when a work order changes. An invocation channel calls out and waits for the answer, and the REST/OSLC API sits beside them.
- Sequential and continuous queues. Two queues receive the same messages, one of them bad. The sequential queue keeps order and stops at the bad message. The continuous queue processes in parallel, retries and parks the bad one, and keeps going. Both list the failure in Message Reprocessing, where it is fixed and sent again.
- Cron tasks and escalations. A clock ticks. Cron tasks run jobs on schedule: generate PM work, read queues, run escalations. An escalation checks for priority 1 work still waiting after two hours and sends the supervisor a notice.
- A workflow route. A workflow drawing: Start, a supervisor approval task, a condition on cost, then approved or rejected paths ending at Stop. A record token travels the route.
Builder
- The test pyramid. 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.
- Stub, mock and the real thing. A test talks to three stand-ins. The stub returns a canned answer. The mock returns an answer and also checks it was called once with the right values. The real Maximo is slow, shared and full of data you must not change.
- Back off and retry. A client gets 429 Too Many Requests and waits before trying again, waiting longer each time with a little randomness, until it gets 200. Beside it, a client that retries instantly makes the storm worse.
- A pipeline with gates. 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.
- CI, continuous delivery, continuous deployment, CT. Four lanes. CI: every commit is built and tested. Continuous delivery: every passing change waits ready, and a person presses release. Continuous deployment: every passing change goes live on its own. Continuous testing: tests run at every stage.
- An mxR work order moves site to site. 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.
- The path rule sorts every change. 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.
- The job plan board. A board of task cards in order: lint, DBC, Migration Manager preview, deploy, smoke, API, script tests, cron, MIF, UI journeys, golden screens and drift. Each card has On, Gate and Test switches. Dragging a card into a site column adds it.
- Ranks of evidence. 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.
- Which tool answers which question. 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.
- AI at build time, facts at run time. 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.
- Your upgrade is a diff. 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.
- mxH grades. 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).
- mxH evidence classes. 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.
- A data load you can prove. 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.
- AddChange, Sync and Delete. The same sheet loaded three ways onto a record with child rows. AddChange adds and updates. Sync adds and updates and also removes the child rows missing from the sheet. Delete removes the records.
- Reconcile: prove what landed. 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.
- An upgrade, start to finish. 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.