How to Write and Validate MSP Runbooks

November 15, 2026 · 1257 words

Published by Steven Delaney

Two IT support colleagues checking a procedure beside an open laptop

A useful MSP runbook lets an appropriately trained technician complete a defined task, recognize whether it worked, and stop when the situation falls outside the procedure. It carries the decisions that would otherwise require a call to the person who wrote it.

The difficult part is uncovering what that person does without thinking: checking the client before selecting a system, recognizing an unexpected result, or knowing which apparently harmless action interrupts other users. Those details need to survive the move from an expert's memory into written instructions.

Start with one repeatable task. Write it while observing the work, have another technician follow it, and publish the version that has actually been checked.

Choose a task with a clear finish

Look for work that regularly requires the same explanation or returns to a particular technician. A good starting candidate has a recognizable trigger, a bounded scope, and an outcome someone can verify. Connecting a replacement workstation to an approved shared printer is more manageable than documenting everything about printing.

Review resolved tickets for candidates, but check what their outcomes establish. A restart followed by a quiet ticket does not prove that restarting is the right procedure for every similar symptom. The investigation behind fixing recurring MSP tickets can distinguish a verified correction from a temporary recovery step.

Keep unresolved diagnosis visible. If the technician must first determine which of several unrelated faults exists, write that investigation separately or identify the decision that selects this procedure. A runbook should not turn an uncertain hypothesis into an instruction to change production.

Define the scope before the steps

Give the procedure a title that names the task and its supported context. Record the client or service it applies to, relevant system versions, the intended reader, and the conditions under which it may be used. Explain exclusions where confusion is plausible.

For the printer example, distinguish reconnecting a workstation to an existing approved queue from replacing the print server, changing printer permissions, or clearing a shared queue. Those tasks have different effects and may need different authorization.

State what the reader must already know. A procedure for a service desk technician can assume basic workstation navigation while still identifying the exact client environment and approved management route. Write down the client-specific knowledge that cannot reasonably be assumed.

Put preparation where the reader will see it

Unmarked folder, portable drive, disconnected cable, and pen arranged on a desk

Place prerequisites before the first action. Include the approved request or change reference, required access, supported tools, maintenance restrictions, and any preparation needed to recover from an unsuccessful attempt. Confirm that the reader can reach the documentation through the access routes available during the task.

A compact runbook record can contain:

  1. Purpose and scope: The task, supported environment, and expected outcome.
  2. Before starting: Authorization, access, tools, and conditions that must be true.
  3. Steps and checkpoints: Actions in order, with the result expected after important steps.
  4. Exceptions: Results that require a different path or an immediate stop.
  5. Recovery and escalation: Approved restoration steps and the responsible contact or role.
  6. Completion evidence: Checks, observations, and records needed to finish the work.
  7. Ownership and version: Maintainer, revision, validation date, and review triggers.

Reference credentials through the approved secret store. Do not paste passwords, recovery codes, or client data into example commands or screenshots. Keep shared instructions reusable and store restricted client details in the appropriate protected record.

Write actions with observable checkpoints

Use one meaningful action per numbered step. Identify the object being changed before describing the action. Replace vague directions such as "select the usual printer" with instructions for confirming the authorized queue from the client's current configuration record.

Separate observations from changes. First confirm the workstation, signed-in user, and destination. Then describe the approved connection method. Afterward, check the result from the application and user context that matter to the request.

In a hypothetical printer runbook, completion could require a harmless test page reaching the intended device and the user confirming that the required application can print. The procedure should explain what to record if connection succeeds but the application test fails. Installing a queue and completing the user's task are separate observations.

Name stopping conditions at the relevant step. An unexpected destination, unsupported driver, missing authorization, or warning about wider service impact should lead to a defined decision. Do not ask the reader to improvise around an unfamiliar warning or repeatedly retry an action without understanding its effects.

Validate with someone who did not write it

A technician working at a laptop while a colleague observes from the side

Choose a reviewer with the skills and access expected of the intended reader. Give them the draft and an appropriate test setting. Ask the author to observe without supplying missing directions. Every clarification is useful evidence about what the document needs to say.

Use a representative non-production environment when available. Where validation requires live work, obtain the relevant authorization and use the agreed service window. Do not create a client interruption merely to check that an exception paragraph sounds plausible.

Record the environment, runbook revision, steps exercised, observed outcomes, and questions raised. Distinguish an executed test from a discussion of what someone would do. If recovery or an unusual branch was only reviewed at a desk, label it accordingly rather than claiming the whole procedure was tested.

Revise the unclear steps and repeat the affected portion. Check whether the reader can identify the right procedure, complete its checks, and recognize when it does not apply. Fast execution is useful only after those conditions are satisfied.

Publish one authoritative procedure

Put the approved runbook in the team's established documentation system. Make it discoverable from the request type, service record, or other place technicians begin the work. Use a title containing the terms they are likely to search for.

Link tickets to that versioned procedure instead of distributing independent copies through chat or attachments. Record the revision used where it matters for understanding the work. Preserve enough history to establish which instructions were available at the time.

Keep generic steps separate from client-specific parameters where that makes maintenance clearer. Avoid creating several nearly identical procedures with no identified shared owner. Equally, do not force genuinely different client environments into a universal document full of ambiguous exceptions.

Keep validation tied to system changes

Assign an owner who can review technical changes and a backup for their absence. Include documentation impact in the MSP change management process. A changed queue, permission model, management tool, or supported version may alter the procedure even when its title remains accurate.

Set review intervals according to how often the environment changes and the consequences of incorrect instructions. Add event-driven reviews when technicians report a mismatch or a task produces an unexpected result. A calendar reminder alone cannot catch a procedure broken by yesterday's change.

Use a service desk ticket quality review to sample completed work that cites the runbook. Check whether technicians used the current revision, recorded the expected verification, and needed undocumented assistance. Treat repeated workarounds as a reason to revise the procedure.

Begin with a small set of frequently needed tasks and track the gaps discovered during real use. A useful library grows from procedures that another technician can find, follow, and verify. Its value comes from dependable work, rather than the number of pages published.

Steven Delaney avatar

Steven Delaney

MSP Industry Expert • Houston, TX

Strategic insights and practical guidance for the modern Managed Service Provider. Based in Houston, TX.