Assetize

Learning Lab

Level 1 · 15 levels · Foundations · about 70 minutes

Level 1 — How software talks: HTTP, APIs and JSON

By the end: Read and write an HTTP request by hand, explain what 200, 201, 400, 401, 403, 404, 429 and 500 mean and what to do about each, read a JSON answer, keep an API key safe, and call Maximo's REST API with curl.

Almost every program you will build talks like this. A client sends a request across the network: a method, an address, some headers and sometimes a body. The server sends back a response: a status code and a body. Watch the packet go there and back.

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.

Lesson 1

A request and a response

Programs talk to each other by sending messages over a network. The program that asks is the client. The program that answers is the server. Your web browser is a client; the website is a server. A technician's phone app is a client; Maximo is the server. Most of these conversations use HTTP, the HyperText Transfer Protocol: a short set of rules for what a message must look like. HTTPS is the same thing with encryption added, so nobody in between can read or change the message. Real Maximo systems always use HTTPS.

The conversation is always the same shape. The client sends one request. The server sends back one response. That is the whole idea, and everything else in this level is detail on top of it.

A request and a response. A laptop sends a request to a server and gets a status code and a body back. Watch the packet go there and back, then press Replay and say each part out loud as it moves.

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.

Part of the requestWhat it saysExample
MethodWhat you want to doGET (read)
Address (URL)What you want it done to/maximo/api/os/mxapiasset
HeadersExtra facts about the request, as name: value linesapikey: (your key)
Body (optional)The data you are sending{"description": "Seal leak"}

Here is a real request written out as plain text, exactly as it travels. The first line holds the method, the address and the HTTP version. Each header sits on its own line. A blank line ends the headers.

A request, as it travels (the host is a placeholder)

GET /maximo/api/os/mxapiasset?oslc.select=assetnum,status HTTP/1.1
Host: maximo.example.com
apikey: (your API key)
Accept: application/json

The response comes back in the same shape. Its first line holds the status code, a three-digit number that says what happened. Then come the response headers, a blank line, and the body: the data you asked for, here in JSON (Lesson 4).

The response (body trimmed to one record)

HTTP/1.1 200 OK
Content-Type: application/json

{"member": [{"assetnum": "PUMP-101", "status": "OPERATING"}]}

The mistake: Assume that if no response came back, nothing happened on the server. Do this instead: The server may have done the work and the answer got lost on the way back. Lesson 2 shows how to design requests that are safe to send again.

Remember: One request, one response. When something breaks, find the request that was sent and the response that came back. Everything starts there.

Lesson 2

Addresses and methods

An address, or URL, names the thing you want. Read it left to right and it narrows down, like a postal address from country to house. Here is a full Maximo address, the kind you will write every day.

One Maximo address, five parts

https://maximo.example.com/maximo/api/os/mxapiwodetail?oslc.select=wonum,status&oslc.pageSize=2
PartIn the exampleWhat it is
Schemehttps://How to talk: HTTP with encryption
Hostmaximo.example.comWhich server
Path/maximo/api/os/mxapiwodetailWhich thing on that server: the work order object structure
Query string?oslc.select=wonum,status&oslc.pageSize=2Settings for this request. ? starts it, & separates the settings, = joins a name to its value

Some characters mean something special in an address, so they are encoded as a % sign and two hex digits. A space becomes %20, a double quote becomes %22 and a plus sign becomes %2B. IBM's REST API guide warns about the plus sign in particular: in a sort order such as oslc.orderBy=+wonum, the + must be sent as %2B or the server reads it as a space.

The method says what you want done to the thing at that address. There are only a handful, and you will use four of them most days.

MethodMeansChanges data?Safe to send twice?
GETRead itNoYes
POSTCreate something new, or run an actionYesNot by itself: twice can mean two records
PUTReplace it completelyYesYes: the second one changes nothing more
PATCHChange part of itYesDepends on the change
DELETERemove itYesYes: it is already gone

"Safe to send twice" has a proper name: idempotent. A request is idempotent when sending it twice leaves the system the same as sending it once. That matters because networks drop answers. If your program cannot tell whether a create worked, it is tempted to send it again, and a plain POST can then create a second work order.

Safe to press twice. A request is sent, the network drops the answer, and it is sent again. Left: without protection, two records. Right: with an idempotent request, still one record.

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.

Maximo has one twist you must remember. Its REST API updates an existing record with a POST to that record's address plus a header, x-method-override: PATCH. IBM's guide says the header "instructs the server side to update the resource". Creates are a POST to the collection address, such as /maximo/api/os/mxapiwodetail, with the new record as JSON in the body.

A request and a response. A create: POST to the work order collection, with a JSON body. The server answers 201 Created.

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.

The mistake: Put an API key or a password in the query string because it is quicker. Do this instead: Query strings end up in server logs, proxy logs and browser history. Send secrets in headers. IBM recommends the apikey header over the query parameter for exactly this reason.

Remember: GET reads and never changes anything. If a GET ever changes data in something you build, that is a bug.

Lesson 3

Status codes: the first thing to read

Every response starts with a three-digit status code. Read it before anything else. The first digit tells you the family, and the family tells you what to do next. The HTTP standard (RFC 9110) defines five families: 1xx information, 2xx success, 3xx redirection, 4xx client error and 5xx server error. Day to day you will live in three of them.

Status code families. Three lanes. Green 2xx: it worked. Amber 4xx: your request needs changing. Red 5xx: the server has a problem. Each code has its own small picture: remember the picture and you remember the code.

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.

CodeNameWhat it means for youWhat to do
200OKIt worked. The data is in the body.Read the body
201CreatedYour new record was made.Read the new record's address and fields
204No ContentIt worked, and there is nothing to send back.Carry on
400Bad RequestThe server could not or would not accept your request. In Maximo this is often a business rule saying no.Read the error message and fix the request
401UnauthorizedYou did not prove who you are: no key, or a wrong or revoked key.Check the key and how you send it
403ForbiddenThe server knows who you are, but you may not do this.Ask for the right permission
404Not FoundThe address or the record is not there.Check the spelling of the path and the record id
429Too Many RequestsYou are sending too fast.Wait, then try again, waiting longer each time
500 / 503Server error / Service unavailableSomething broke or is overloaded on the server side.Retry later; tell the people who run the server
Status code families. The code you will meet first in the sim: 401. Learn its picture now and you will spot it in a second.

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.

The 401 and 403 pair confuses everyone once. 401 is about identity: "I do not know who you are." 403 is about permission: "I know who you are, and the answer is no." Fix a 401 with credentials. Fix a 403 with permissions.

A Maximo error answer has a body that explains itself. Its reasonCode is an IBM message number starting with BMXAA, and the message says what the business rule objected to. You can look up any BMXAA code on the Assetize error lookup page.

The shape of a Maximo error answer (message trimmed)

HTTP/1.1 400 Bad Request
Content-Type: application/json

{
  "Error": {
    "reasonCode": "BMXAA4129E",
    "message": "BMXAA4129E - The record for ... already exists. Ensure that the key value for the given record is unique.",
    "statusCode": "400"
  }
}

429 deserves special care. Gateways in front of busy systems answer 429 when a client sends too much too fast. A good client waits and tries again, waiting longer each time, with a little randomness so a crowd of clients does not retry in step. That is called exponential backoff with jitter. A bad client retries at once and makes the storm worse.

Back off and retry. A client gets 429, waits, gets 429 again, waits longer, and gets 200. Retrying instantly would only add to the pile.

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.

The mistake: Treat every answer that is not 200 as "failed, try again". Do this instead: Read the family. Retrying a 400 sends the same wrong request again; a 201 is a success. Retry only 429 and some 5xx, with backoff, and read the error body for everything else.

Remember: 2xx: good. 4xx: change your request. 5xx: the server has a problem. 429: slow down.

Lesson 4

JSON: how the data looks

Most APIs, Maximo's included, send data as JSON, short for JavaScript Object Notation. JSON is plain text with a few strict rules, so both people and programs can read it. It has only six kinds of value. Learn these six and you can read any JSON.

KindLooks likeMaximo example
String (text)In double quotes"PUMP-101"
NumberDigits, no quotes18500
Booleantrue or false, no quotestrue
Nullnull: no valuenull
ObjectCurly brackets around name: value pairs{ "wonum": "1002", "status": "APPR" }
Array (list)Square brackets around values[ "APPR", "INPRG" ]

Objects and arrays nest inside each other, which is how one answer can hold a list of records, each with its own fields. Maximo wraps the records it returns in a list called member. IBM's REST API guide says it directly: "the result is boxed under the member JSON array." Next to member sits responseInfo, which carries facts about the query itself, such as the address of the next page.

A Maximo answer: a list of two work orders (sample data from the sim)

{
  "member": [
    { "wonum": "1002", "status": "APPR",  "description": "PUMP-102 seal leak, standby pump" },
    { "wonum": "1003", "status": "INPRG", "description": "CONV-301 belt tracking off centre" }
  ],
  "responseInfo": { "nextPage": { "href": "(address of page 2)" } }
}
JSON as text and as a tree. The same answer twice: as text on the left and as a tree on the right. As each bracket lights up, its node in the tree lights up too. Text and tree are the same data.

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.

To reach one value, walk down the tree. member is the list. member[0] is the first record in it, because lists count from zero. member[0].wonum is "1002". Every programming language you will use has a built-in way to turn JSON text into a tree like this, called parsing. In JavaScript it is JSON.parse.

JSON as text and as a tree. An asset record as JSON. Same rules: an object, names on the left, values on the right, and lists for anything that repeats.

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 mistake: Write JSON with single quotes, a comma after the last item, or comments, then cut values out of the text with string searches. Do this instead: Use double quotes, no trailing commas and no comments. Let the language parse the JSON, then read values from the tree.

Remember: Curly brackets: one thing with named parts. Square brackets: a list of things.

Lesson 5

APIs, and the key that opens them

An API, or application programming interface, is a set of addresses and rules that lets one program use another. It is a contract: send this, and you get that back; get it wrong, and you get this error. Maximo has a REST API, so an ERP finance system, a mapping system, a mobile app or an Assetize product can read and change Maximo data without anyone clicking through screens. The changes still pass through Maximo's business rules, exactly as if a person had made them on screen. Level 4 shows you why.

Before an API does anything for you, it needs to know who you are. That is authentication. Then it decides what you may do. That is authorisation. A 401 is an authentication failure; a 403 is an authorisation failure.

Maximo's answer for programs is the API key: a long secret string that stands in for a user. IBM's documentation sets out the rules, and they are worth learning word for word.

  • An API key belongs to one Maximo user. IBM: "The permissions that are associated with the API key are determined by the permissions for the associated user."
  • You send it in every request, as an apikey request header or an apikey query parameter. IBM recommends the header, for security.
  • Administrators create keys in the API Keys application. IBM's REST guide also shows a user creating their own key, and says a key can have an expiry in minutes, where -1 means it never expires.
  • Calls made with a key use a "silent" login: by default no server session is created, so there is nothing to log out of.
  • The way to stop a key working is to revoke it.
No key, no data. With a key the door opens and records come out with 200. The key works because it belongs to a real Maximo user, and it can do only what that user may do.

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.

maxauth (classic 7.6.1 integrations)API key (MAS)
  • A user name and password joined and base64-encoded
  • Base64 is an encoding, not encryption: anyone who sees it can read the password
  • Common in older integrations
  • MAS 9 inbound calls use API keys instead
  • A long secret tied to one Maximo user
  • Sent as the apikey header
  • Revoke it and it stops working at once
  • No session to manage

An API key is as powerful as the user behind it, so treat it like a house key. Never type it into code, commit it to Git, paste it into a ticket or send it in chat. Keep it in an environment variable or a secret store, where only the running program can read it. The sim shows the habit: you type $apikey and the terminal fills in the value, so the real key never appears in your commands.

Where secrets live. Top: a key typed into code is committed, pushed and copied to everyone who can read the repository. Bottom: the same key in an environment variable store, read only by the running program.

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.

The mistake: Paste a working API key into source code "just for now", or into a chat message so a colleague can test. Do this instead: Put it in an environment variable or a secret store. If a key has been seen anywhere it should not be, revoke it and make a new one straight away.

Remember: A 401 from Maximo means "no key, or a wrong key". It never means "no data": Maximo has no anonymous door.

Lesson 6

curl: talking to an API by hand

curl is a small command-line program that sends HTTP requests and prints the response. It comes with macOS, Linux and modern Windows. Developers use it every day to try an API by hand before writing any code, and to reproduce a failing request exactly. The sim on this page understands curl, so everything here works in the terminal below.

The parts of a curl command. One curl command, labelled part by part: the program, the -H header carrying the API key, the address, the object structure name, and the query settings after the question mark.

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.

FlagWhat it doesExample
-HAdds a request header-H "apikey: $apikey"
-dSends a body (and makes the request a POST)-d '{"description":"Seal leak"}'
-XSets the method by name-X DELETE
-iShows the status line and response headers toocurl -i ...
-sSilent: hides the progress metercurl -s ...

curl in the sim (on a real system the address starts with https:// and the host)

# Read two work orders, only their number and status
curl -H "apikey: $apikey" "/maximo/api/os/mxapiwodetail?oslc.select=wonum,status&oslc.pageSize=2"

# The same, showing the status line and headers
curl -i -H "apikey: $apikey" "/maximo/api/os/mxapiwodetail?oslc.pageSize=1"

Quoting matters, and it trips everyone up once. Wrap the whole address in double quotes. Without them, the shell reads the & between query settings as "run this in the background" and cuts your address in half. Use double quotes, not single quotes, around anything that contains $apikey: inside single quotes the shell sends the letters $apikey instead of the key, and Maximo answers 401. When a filter needs quotes inside the address, put a backslash before each inner double quote.

A filter inside a quoted address

# Only approved work orders: the inner quotes are escaped with backslashes
curl -H "apikey: $apikey" "/maximo/api/os/mxapiwodetail?oslc.where=status=\"APPR\"&oslc.select=wonum,status"
The parts of a curl command. The query settings after the question mark, lit up. They decide which fields come back, which rows, and how many at a time.

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.

The mistake: Write a whole program first, then wonder whether the bug is in the code or in the request. Do this instead: Make the request work in curl first. When curl gets the answer you want, copy the method, address, headers and body into your code.

Remember: When a request fails, add -i and read the first line. The status code tells you which lesson of this level to reread.

Lesson 7

Maximo's REST API at a glance

Now put it together for Maximo. Maximo's REST API speaks JSON over HTTP. What it serves are object structures: named bundles of Maximo objects. MXAPIWODETAIL is a work order with its tasks, planned labour and planned materials. MXAPIASSET is the asset register. MXAPIPM holds preventive maintenance records, MXAPIINVENTORY the storeroom balances, MXAPIPO purchase orders. IBM's REST guide calls object structures the resources of the REST API. Assetize's catalogue counts 535 API object structures in Maximo 9.2, and a GET to /oslc/apimeta lists them all with their schemas.

An object structure bundles objects. The MXAPIWODETAIL object structure: WORKORDER with its children, tasks, planned labour and planned materials. One API call reads the whole bundle in one answer.

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.

Piece of https://maximo.example.com/maximo/api/os/mxapiwodetailWhat it means
maximo.example.comThe server your Maximo runs on
/maximoThe Maximo application on that server
/apiThe REST API route
/osShort for object structure: what comes next is one
/mxapiwodetailThe object structure's name: work orders with their tasks, labour and materials

You will also see the older route /maximo/oslc/os/... in IBM's examples. It serves the same object structures. Add lean=1 to get plain JSON without namespace prefixes on the field names: IBM recommends setting lean=1 on every request on that route.

Query settingWhat it does (IBM's words, shortened)Example
oslc.selectThe attributes to fetch, including from related objectsoslc.select=wonum,status,description
oslc.whereThe WHERE clause that filters the result setoslc.where=status="APPR"
oslc.pageSizeHow many records to fetch per pageoslc.pageSize=10
oslc.orderBySort order: - for descending, + (sent as %2B) for ascendingoslc.orderBy=-wonum
Build a REST query. Tick fields, pick a status and a page size, and watch the address build itself while the small result table changes to match. This is exactly what your code will do.

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.

IBM's filtering rules in brief: text and dates go in double quotes, numbers and booleans do not; = is equals, > and < compare; in [...] matches a list; % is a wildcard inside text. So status in ["APPR","INPRG"] finds work that is approved or in progress, and description="%LEAK%" finds anything mentioning a leak.

The verbs on a record. Four things you can do to a record: GET reads it, POST creates a new one, POST with x-method-override: PATCH changes it, and an action call runs Maximo business logic on it.

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.

You want toSend
Read a listGET /maximo/api/os/mxapiwodetail?oslc.select=...&oslc.where=...
Read one recordGET the record's own address (its href)
Create a recordPOST /maximo/api/os/mxapiwodetail with a JSON body; add a properties header to have fields echoed back
Change a recordPOST to the record's address with x-method-override: PATCH and the changed fields
Run an actionPOST to the record's address with ?action=wsmethod:approve (IBM's example) and x-method-override: PATCH

When a create succeeds, Maximo answers 201 Created. IBM's guide says the response carries a location header with the address of the new record, and the properties header "removes the need to do an extra GET for every create and update".

Calling Manage from the outside, drawn

The mistake: Fetch every work order and filter them in your own code. Do this instead: Let Maximo do it. oslc.where filters on the server, oslc.select trims the fields and oslc.pageSize keeps each answer small. You fetch the rows you need, never the whole table.

Remember: Now do the missions below. Knock on Maximo without a key, then with one, and watch the status code change from 401 to 200.

Level 1 missions in the Maximo sim

  1. Knock without a key. Ask Maximo for work orders without sending any key. Watch what comes back.
  2. Knock with a key. Send the same request again, this time with the API key in a header. Get a 200.

Real practice on the Maximo SIM

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

  1. Knock on a real Maximo API without a key (DEV). The terminal sim showed a 401. Now see a Maximo-shaped server say the same thing, with a real BMXAA reason code.
  2. Ask the SIM who you are, with your API key (DEV). An API key proves who you are without a password. whoami answers with your own user record.

Check yourself: the Level 1 quiz

18 questions. Pass mark 70%.

  1. Look at the picture. Which part of the request says what you want to do: read, create, change or remove? (picture: A request and a response)
    • The status code
    • The method
    • The body
    • The host name
  2. Which HTTP method reads data without changing anything?
    • POST
    • GET
    • DELETE
    • PATCH
  3. Look at the enlarged code. Maximo sent it back. What is the most likely cause? (picture: Status code families)
    • The server crashed
    • You sent no API key, or a wrong one
    • The record was created
    • You are sending too fast
  4. Maximo knows who you are, but your user may not change purchase orders. Which code fits?
    • 401
    • 403
    • 404
    • 500
  5. You POST a new work order and get 201. What does that mean?
    • The request failed
    • The new record was created
    • Try again later
    • The address was wrong
  6. Which picture shows the code you get when the address or the record is not there?
    • Picture A
    • Picture B
    • Picture C
  7. Look at the client in the picture. It got 429 Too Many Requests. What is it doing right? (picture: Back off and retry)
    • Sending the same request again at once, many times
    • Giving up and crashing
    • Waiting, then trying again, waiting longer each time
    • Deleting the record
  8. In a Maximo JSON answer, which name holds the list of records? (picture: JSON as text and as a tree)
    • data
    • records
    • member
    • items
  9. In JSON, what do square brackets [ ] hold?
    • One value
    • A list of values
    • A comment
    • A header
  10. Which of these is valid JSON?
    • {"wonum": "1002", "status": "APPR"}
    • {'wonum': '1002'}
    • {wonum: 1002}
    • {"wonum": "1002",}
  11. The lit part of this curl command does what job? (picture: The parts of a curl command)
    • Sets how many rows come back
    • Sends the API key as a header, so Maximo knows who you are
    • Names the server
    • Saves the answer to a file
  12. The lit part of the address names what? (picture: The parts of a curl command)
    • The user
    • The object structure: the bundle of Maximo objects this request reads
    • The status filter
    • The page size
  13. An API key in Maximo belongs to what?
    • Nobody: it has full access
    • A Maximo user, and calls made with it have that user's permissions
    • The server itself
    • Only the administrator group
  14. Look at the picture. What went wrong? (picture: Where secrets live)
    • Nothing, this is the right way
    • The key was typed into code, committed and pushed, so everyone who can read the repository has it
    • The key expired
    • The server lost the key
  15. You can send a Maximo API key as a header or a query parameter. Which does IBM recommend, and why?
    • The query parameter, because it is shorter
    • The header, for security: query strings end up in logs and history
    • Either, it makes no difference
    • Neither: use maxauth
  16. This request has no key. What does Maximo send back? (picture: No key, no data)
    • 200 and an empty list
    • 401 Unauthorized
    • 404 Not Found
    • 201 Created
  17. You need only the approved work orders. What is the best request?
    • Fetch every work order, then filter in your code
    • Add oslc.where=status="APPR" so Maximo filters on the server
    • Ask an administrator for a spreadsheet
    • Send a DELETE for the others
  18. Look at the lit action. How do you change an existing record through Maximo's REST API? (picture: The verbs on a record)
    • GET with the new values in the address
    • POST to the record's address with the header x-method-override: PATCH
    • DELETE it and create it again
    • Edit the database directly

Remember it as a picture

  • Request and response: A client sends a method, an address, headers and maybe a body. The server answers with a status code and a body.
  • POST with a body: Creates something new. In Maximo, a POST to the object structure with JSON creates a record and answers 201.
  • 200 OK: It worked. The data is in the body.
  • 401 Unauthorized: You did not prove who you are: no API key, or a wrong one. Maximo never answers an anonymous call with data.
  • 403 Forbidden: The server knows who you are, but you may not do this. Fix it with permissions, not with a new key.
  • 429 Too Many Requests: Slow down. Wait, then retry, waiting longer each time with a little randomness.
  • JSON: Text data with six kinds of value. Curly brackets: an object. Square brackets: a list. Maximo puts records in member.
  • curl: A command-line tool that sends HTTP requests. -H adds a header, -d sends a body, -i shows the status line.
  • API key: A secret tied to one Maximo user, sent as the apikey header. Calls run with that user's permissions.
  • Keep keys out of code: Keys live in an environment variable or a secret store. If one leaks, revoke it and make a new one.
  • Idempotent: Safe to send twice: the second request leaves the system exactly as the first one did.
  • oslc.select, oslc.where, oslc.pageSize: Choose the fields, filter the rows on the server, and set how many come back per page.
  • Object structure: A named bundle of Maximo objects the API serves, such as MXAPIWODETAIL: a work order with its tasks, labour and materials.

Where these facts come from

Try it on the real tools

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