Gaps in skill set and a lack of automation are among the top challenges faced by IT professionals today. This is according to a 2020 report by Global Knowledge.
Runbooks are created by IT professionals to give everyone on the team – new or experienced – the knowledge and steps needed to resolve a given issue thrown their way. In addition, these steps can be automated using runbook automation.
As such, we can say runbooks are a useful tool to solve the twenty-first-century challenges IT professionals face. It‘s for this reason we’ve created this FAT FINGER article – your ultimate guide on how to create a runbook in 14 steps.
In this article, you’ll learn what a runbook is, what runbook automation is, and how to implement it. You’re then given 14 steps to guide you through creating your own runbook including the essential elements.
- What is a runbook?
- Understand runbook automation
- 14 steps on how to create a runbook
- Elements included in an effective runbook
Let’s jump to it!
What is a runbook?
A runbook is a compilation of standardized documents, references, and procedures used by IT professionals to explain common recurring IT tasks. Rather than having to figure out the given problem time and time again, the IT professional can refer to the runbook as an optimal means of getting the work done.
System administrators, IT departments, and NOCs use runbooks as a reference. They can be either electronic or in a physical book form. An effective runbook will allow IT professionals – with the prerequisite expertise – to manage and troubleshoot IT systems.
IT teams are provided with contextual documents for consistency and efficiency through standardization. Runbooks act as a walkthrough or step-by-step guide for both new and experienced IT professionals. This closes skill-set gaps as runbooks become the one reference point for all team members. They are used to optimize routing IT operations, troubleshooting, and for incident management to reduce system downtime.
There are two main types of runbook. Those referred to as general documentation and those referred to as specialized documentation.
- General documentation: General documentation is updated by a system when new procedures arise or evolve.
- Specialized documentation: Specialized documentation is written by one team member for a specific use case or for one system.
These runbook types can be further categorized according to the degree of automation used. That is, your runbooks can either be manual, semi-automated, or fully automated:
- Manual runbooks: The steps given describe the exact procedure an operator must follow. The operator uses standard tools, which can be accessed from their working environment.
- Semi-automated runbooks: Each step describes exactly what an operator must do. Additionally, the operator can run an automated task on a target system.
- Fully automated runbooks: The runbook runs automatically without operator interaction.
Understand runbook automation
Runbook automation allows a system’s documented procedures to be carried out without manual input. Runbook automation is designed to increase both efficiency and reliability.
The challenge with runbook automation is recognizing what can be automated and how it can be automated. Fortunately, regarding runbooks, most things can be automated without too much difficulty as we’re talking about computer systems.
Runbook automation needs to be encouraged, and it should never be assumed that an area of development, or operations, cannot be automated. Even with the most nuanced projects, there are often subtasks to automate.
You can use FAT FINGER as a tool to help you implement runbook automation. Record your common runbook tasks in an interactive FAT FINGER procedure. Here you’ll have everything you need to create rich-media runbooks that include images, Conditional Logic, and more.
You want to remove barriers that discourage runbook automation, this means ensuring the creation of new, automatic runbook tasks shouldn’t take longer or need more resources than completing the task manually. With this in mind, runbook automation is easy with FAT FINGER. FAT FINGER’s drag-and-drop workflow builder means coders can quickly implement automated steps in the runbook design.
Document your runbook as an active workflow, and then use FAT FINGER’s Conditional Logic feature to automatically check variables. You can deploy different responses for each variable combination that brings up a unique issue resolution automatically. You’ll quickly create a network with many resolution branches using if-that-then-this logic.
Next, run through the 14 steps below which detail how to create a complete runbook from scratch.
14 steps on how to create a runbook
Organizations need detailed runbooks once effective operation tasks have been established by their IT team. Runbooks can be made proactively by anticipating potential IT system failures, or after analyzing incident reports.
It’s important to note that every runbook is unique and specific. However, the basic steps remain the same regardless of runbook type and function. Here we split runbook creation into 14 steps. Each step constitutes a stage in the runbook creation process. Stage 1 is planning, stage 2 is creation and the final stage 3 is testing.
Creating a runbook stage 1: Planning
Step #1: Overview
First-off, gain an overview of the IT services in question. Think about what it is, why we have it, who are the primary contacts, how to report bugs, links to design documents plus other relevant information.
Step #2: Take a look at your detailed incident reports
What are the most common incidents or tasks your team faces?
Take a look at detailed incident reports to identify areas in your IT processes where a runbook can be effectively implemented. Look out for areas where there are recurring tasks and issues to increase accuracy, efficiency, reduce errors and boost process speed.
Step #3: Prioritize processes
Create your first runbooks for processes performed the most frequently and with high error rates, as well as for processes that pose the greatest operational and financial risks.
Step #4: Document your optimal solutions
Using your incident reports, see how issues have been resolved in the past. See if the most effective resolution method has been used, and find the most efficient and accurate means of solving these issues. You want your runbook to take the best possible solution and present this solution clearly to the operator.
Using FAT FINGER you can document these optimal solutions as a checklist procedure. Your FAT FINGER runbooks then act as a vehicle for automation.
Step #5: Create a runbook template
Use a template to ensure each runbook contains the necessary information.
You want to include: An overview of the process; the process steps; technical documentation; personnel permissions and authorizations; escalation protocols, and the required reporting and communications.
Just as you can document your runbooks in FAT FINGER, you can also document a runbook creation template as a FAT FINGER checklist. This way, whenever a team member wants to create a runbook, regardless of their experience, they can open up your runbook creation template, and simply follow the process.
Creating a runbook stage 2: Creation
Step #6: Complete process documentation
From your documented optimal solutions, it’s now time to complete your runbook. You want your runbook to contain the following sections:
- Service overview
- Service build information
- Instructions for deploying the software
- Instructions for common tasks
- “Pager Playbook” – An outline of every possible monitoring system alert and step-by-step instructions for when they are triggered
- Disaster recovery plans
- Service level agreement
Don’t write your IT processes from memory. Use your process documentation tool, FAT FINGER, to work through the process steps, take notes and capture the details of your procedures. The details can then be accessed by the relevant personnel at any time from their FAT FINGER account.
Step #7: Include essential information
When documenting your procedure, make sure to include hardware and software technical specifications, configuration information, network diagrams, and login credentials.
Step #8: Set up alerts
Create a system that will alert users when the runbook is needed. You can use FAT FINGER’s Alerts and Notifications feature to connect your IT processes with your runbook, and notify individuals when the runbook is needed.
Step #9: Set up the required permissions and communications
Determine who is authorized to use the runbooks and who has the permissions required to execute the procedures. Once the required permissions have been established, you’ll need to use the necessary reporting guidelines for runbook initiation, completion, and after-action review (AAR).
Step #10: Make sure your runbook is user friendly
Make sure to write runbook documentation in a language that anyone can understand. You want staff at every level understanding the runbook for training and onboarding purposes. This means avoiding making assumptions about the skill levels of the user and reducing unduly technical language and abbreviations.
Creating a runbook stage 3: Testing
Step #11: Test your runbook
Multiple in-house IT personnel should test each runbook for accuracy and relevance. The first time your runbook is battle-tested you’ll notice errors.
You also want to collate feedback from your new hires to gain a different perspective and avoid IT groupthink.
Using this feedback, you must create a system that’s adaptable so that errors are easily resolved. With FAT FINGER, runbooks can be updated in the moment, at a click of a button, in the cloud.
Step #12: Perform post-incident reviews
Runbooks used in response to critical events or system failure must be assured during your AAR review. AAR is a structured review or de-brief process for analyzing what happened, why it happened, and how it can be done better. Your AAR review will identify any changes that need to be made.
Step #13: Execute the required system updates
By carefully evaluating your existing runbook you’ll understand what updates are needed to make changes to your hardware, software, or network. A runbook runs best when it’s flexible and easily adaptable to the ever-changing environment of IT operations.
Step 14: Automate your runbook
Using your FAT FINGER account, it’s now time to start using Conditional Logic to automate the incident response process. Your automated runbook will take out the tedious challenge of checking variables and understanding which response to deploy. Your FAT FINGER runbook will give you a visual representation of the procedures and which tasks lend themselves to be automated.
Elements to include for an effective runbook
To be effective, a runbook needs to be:
- Actionable: Document what needs to be done following an incident in a way that’s understandable to the user regardless of their expertise.
- Accessible: Team members need to know where to find a given runbook with the relevant permission to access these runbooks.
- Accurate: Runbooks must contain up-to-date and error-free information to ensure the correct incident responses are actioned.
- Authoritative: Create one runbook for each IT process, any more will erode standardization.
- Adaptable: Runbooks need to be easy to modify to prevent future redundancies.
Create your runbook using FAT FINGER
FAT FINGER is a powerful tool helping IT professionals across the globe tackle common challenges such as skill-set gaps and a lack of automation. By documenting your IT runbooks in FAT FINGER, you’ll have a process that walks you through certain tasks with specifically designed steps.
Once more, because you’ve used FAT FINGER’s Conditional Logic feature, the incident response steps presented are unique to the issue at hand. Your runbook process will automatically adapt to your individual needs at that one given time.
For a better understanding of FAT FINGER, and how it can help you create a runbook, watch the below video.
Sign up for your free FAT FINGER account and start documenting your runbook today. You can also document other common IT processes in FAT FINGER. If you need help getting started, why not browse our extensive workflow library.
Here’s to making your job as an IT professional that little bit easier!