By
Mendy Green
July 5, 2024
•
20 min read
Fundamental Skills
Professional Development

Over the years of training and assisting various technicians, I've formed a set of guidelines that I've been known to drill constantly. The other day while talking to a newer technician and working with them I realized that I now have the time I didn't have before to actually write down what I've been ranting about for 14 years. I've dubbed them as the Laws for the Practical Technician.
There's a lot of nuance in each "law" so now that we got the TLDR version out of the way let's dive into the specifics. Note for the purposes of this post, each law has been given a title.
If you run around with your eyes closed expecting nothing to get in your way, you're bound to smack into a wall (or something) and fall down. If you keep your eyes open and aware of your surroundings you can navigate the obstacles and overcome them.
End users typically expect systems to work seamlessly and view issues as problems needing external help. Technicians, on the other hand, approach systems with the expectation that things might not work and are prepared to "figure it out" each time.
Key Points:
Example: When dealing with a software bug, an end user might see it as "broken" and wait for a fix. A technician, however, will explore various angles—checking logs, considering recent changes, and testing different scenarios to identify the root cause, or find a viable workaround
Computers and software are designed to be used, (it's actually the only way they make money!). Therefore, the information needed to operate or troubleshoot them is generally available on the screen or in logs, (although the language can be context-specific for the industry). To effectively identify and solve issues, it's crucial to explore the interface and ask questions. Thoroughly reading on-screen messages and prompts can provide insights into what might be wrong and how to address it.
When encountering an error message or unexpected behavior, don’t rush to conclusions, AND DO NOT SKIP IT!
Instead, read all the details provided. Error codes, system messages, and even seemingly minor details can offer significant clues. For instance, a message that seems obscure at first glance might make sense when considered within the context of the application or system you're working on. Even comparing against a computer that is working, looking for differences in behavior, or order of operations, screen activity, and so on, can provide clues (for example an error that takes a while to appear is likely caused by a timeout, vs an error that appears immediately is likely caused by an immediate rejection).
Example: If a user reports an issue with a software application crashing, instead of just noting "application crashes," you should read any error messages, logs, or system prompts that appear when the crash occurs. These details can guide you towards understanding the root cause and potential fixes.
To effectively troubleshoot, ensure you can recreate the problem and understand its significance. Start by asking the person reporting the issue why it's a problem and why it's important to solve it. Gather as much information as possible to understand all sides of the issue. You should be able to understand the problem at least as well as the person reporting it to you, otherwise how do you expect to fix it? Or even explain it to the next escalation point if you have to reach out for help?
Here are some ways you can work to understand the problem.
Example: If a user cannot access a shared network drive, ask them about any recent changes to their system, any specific error messages they receive, and how critical this access is to their work. Look at what the shared drive is mapped to, and if other people have access to it that are working. Identify the network the user who is complaining about is on and if it has connectivity to the shared drive host. This comprehensive understanding allows you to troubleshoot more effectively and escalate if needed.
Being intentional in your actions means making deliberate, thoughtful decisions rather than taking random stabs at fixing an issue. This approach prevents exacerbating the problem and leads to more efficient troubleshooting. Most technicians below Tier 3 will perform troubleshooting by way of "trying different thing to see what works", this is essentially closing your eyes and trying to pin the tail on the donkey, make sure you understand what is going on, and the logical reason why what you're attempting will affect (either negatively or positively) the current outcome so that you can make progress with every step.
Expand on This:
Example: If a printer isn’t working, don’t randomly try different fixes like restarting the printer, reinstalling drivers, or changing settings. Instead, follow a logical sequence—check for error messages to help point you towards a connection issue or a driver issue.
Always be prepared to reassess what you know. Technology and systems evolve, and what was true yesterday might not hold today. Keeping an open mind and questioning assumptions can lead to discovering the true cause of an issue.
Expand on This:
Example: If a network issue arises, don’t assume it’s due to the same cause as last time. Reevaluate the situation - start the troubleshooting process from scratch everytime until you've identified the root cause to the be the same as last time.
Always have a contingency plan before making changes. Ensure that any action you take can be reversed if it doesn’t resolve the issue or causes new problems.
Expand on This:
Example: Before modifying a system registry, backup the registry or export the key in question. Rename something instead of deleting it, or cut/paste it somewhere else. This way, if the change has unintended consequences, you can easily revert to the previous state.
----
Edit 2024/11/13 | This article has been presented and recorded at The IT Nation Connect 2024 in Orlando, Florida! You can watch it here: https://youtu.be/ZJqhT48pnLU

Episode 22 of By the [run]Book dives deep into HaloPSA v2.216, covering a wide range of enhancements across reporting, integrations, invoicing, ticketing, assets, and automation. Connor and Mendy spend extra time unpacking new SLA-aware database functions, improved integrator troubleshooting, OAuth token management, sensitive ticket controls, and several quality-of-life improvements that make Halo easier to administer and automate. This episode is particularly valuable for MSPs looking to improve reporting accuracy, streamline integrations, and gain better visibility into backend processes.
Watch Now: By the [run]Book: Episode 22
For easier tracking, check out haloreleases.remmy.dev to filter and search HaloPSA updates by ID, version, and keyword.
One of the most impactful features discussed in this episode introduces new database functions designed to calculate working time between dates using Halo's own business logic.
Why it matters: MSPs building advanced reporting can now calculate true business time rather than relying on raw SQL date math.
Sensitive tickets gain more granular visibility controls.
Why it matters: MSPs supporting executive teams or handling confidential projects gain stronger access controls.
Connor and Mendy highlighted this as one of the most valuable operational improvements in the release.
Why it matters: Faster troubleshooting means less downtime and quicker resolution when integrations fail.
This feature received strong praise from both hosts.
Why it matters: Anyone building custom integrations or working with APIs will immediately appreciate the time savings.
This feature introduces new database functions that calculate time between dates while respecting Halo's working hours, holidays, and SLA schedules. The hosts highlighted this as one of the most impactful additions in the release for reporting and analytics.
For MSPs building custom reports, this removes much of the complexity previously required to calculate true SLA working time instead of relying on standard SQL date calculations.
Text custom fields created using the newer storage method can now support up to 1000 characters instead of the previous 255-character limitation.
The team discussed real-world examples where long URLs, call recording links, and integration data would previously be truncated. This change reduces the need to switch fields to Memo types simply to accommodate longer values.
Action Group configuration is now surfaced more prominently throughout the Halo interface.
This doesn't introduce new functionality but makes Action Groups easier to discover and manage by exposing configuration options in more logical locations.
Previously, accepted or closed quotes could still transition to an expired status once their expiry date was reached.
This fix prevents completed quote statuses from being overwritten later, resulting in cleaner sales reporting and a more accurate quote lifecycle.
Scheduled nurture campaigns can now periodically re-evaluate recipient lists rather than only processing the list when the campaign initially launches.
This makes nurture campaigns much more practical for dynamic marketing lists where recipients may qualify after the campaign has already started.
The Chat Transcript variable can now be referenced whenever a linked chat exists for a ticket.
This provides more flexibility when building templates, notifications, automations, and workflows that need access to chat history.
A new variable has been added to support invoice long descriptions during pro-rata calculations.
The hosts spent time discussing how this improves consistency between invoice line descriptions and prorated billing entries, helping produce clearer invoices for customers.
Date validation can now be restricted to the creation process only.
This allows administrators to make changes to records later without triggering the same validation requirements that applied when the entity was originally created.
A new permission allows the recorded user associated with device change tracking records to be overridden.
The hosts noted this introduces additional flexibility but also raises questions around auditing and accountability, so it should be used carefully.
Asset system fields can now be configured as visible while remaining read-only.
This helps expose important information to users without allowing accidental edits.
Agreement reference numbers can now be generated on a customer-specific basis.
Organizations with structured naming conventions may find this useful when managing multiple agreements across different customers.
Asset custom fields can now be configured to require unique values.
This is particularly useful for:
It helps improve data quality and prevents duplicate asset records.
Sage Intacct mapping capabilities have been expanded to additional entities.
This improves flexibility for organizations integrating HaloPSA with Sage Intacct accounting workflows.
Custom field mapping support has been extended within the Sage Intacct integration.
This allows more business-specific data to flow between HaloPSA and Sage Intacct.
This setting helps determine how duplicate usernames are handled when new users are created.
The hosts generally felt most organizations would likely continue using traditional username formats rather than switching to email addresses automatically.
This was one of the more significant ticketing enhancements discussed during the episode.
Sensitive tickets now support additional visibility controls for both end users and agents.
This helps organizations handle:
Treeviews can now group agents by their availability status.
Dispatchers and service coordinators may find this particularly useful when reviewing ticket assignments and resource availability.
Asset custom buttons can now suppress the runbook queue confirmation message.
A small but useful quality-of-life improvement for heavily automated workflows.
Chat flows can now retrieve information stored within the user's browser and map that data into Halo records.
The hosts discussed potential use cases while also noting the broader security considerations associated with browser-side data access.
Multi-select custom fields are no longer restricted to integer-based identifiers.
This improves compatibility with external systems that use GUIDs and other non-numeric identifiers.
Additional variables have been added for Client Mention notifications.
This supports richer notification templates and more contextual messaging.
Ticket types can now define a default mailbox during ticket creation.
This provides additional control over ticket routing and mailbox selection.
One of the standout features from the episode, this enhancement makes Halo Integrator troubleshooting significantly easier.
Administrators can now filter logs by configuration ID, making it much simpler to locate and investigate integration runs.
For MSPs managing multiple integrations, this can dramatically reduce troubleshooting time.
Runbook variables can now be JSON-escaped before being passed to external systems.
This helps avoid formatting issues when sending structured data through APIs and automation workflows.
Configuration commit history will now display stored agent names consistently across linked instances.
A small but welcome improvement for organizations managing multiple Halo environments.
A new invoice merging method introduces additional customization options for invoice generation.
The hosts noted that this feature introduces significant complexity and should be thoroughly tested before being adopted in production billing processes.
The Self Service Portal now includes improvements for displaying service status information.
Organizations maintaining customer-facing status pages may benefit from improved visibility during outages and service disruptions.
Another major highlight from the episode.
Administrators can now clear stored OAuth tokens without recreating integrations.
Benefits include:
For anyone building custom integrations, this feature alone can save a significant amount of time.
Ticket column profiles can now display End User and Site-level custom fields.
This allows additional business data to be surfaced directly within ticket lists and views.
Runbook IDs can now be used as a filterable column within integration runbook views.
A small administrative improvement that makes locating specific runbooks easier.
New notification triggers can alert teams when tickets have been inactive for a specified period.
This may help identify tickets that have fallen through the cracks and improve follow-up processes.
Invoice creation now generates trace records that can be used for troubleshooting and diagnostics.
The hosts highlighted the importance of additional visibility into billing processes and invoice generation logic.
Software licence records can now display an end date column.
A straightforward improvement that provides better visibility into licence lifecycle information.
Ticket type groups can now be leveraged within change tracking functionality.
This complements broader improvements around ticket grouping and permissions management.
Automatic invoice reminders can now be configured directly within Halo.
This helps reduce manual collections work and provides a more consistent accounts receivable process.
Approval requests can now be automatically delegated when a user is marked out of office.
While relatively simple today, the hosts discussed how this may become increasingly valuable as Halo continues expanding its out-of-office functionality and approval workflows.

Episode 21 of By the [run]Book dives into the tail end of HaloPSA v2.214 and the first round of v2.216 updates, with Mendy and Connor unpacking practical MSP use cases, hidden configuration gotchas, and workflow improvements. Highlights include forecasting enhancements, category group restrictions, Datto RMM multi-tenancy, auditing improvements, ticket timer widgets, and advanced email handling settings that can dramatically impact service desk operations. This episode is especially useful for Halo administrators refining automation, billing accuracy, integrations, and technician workflows.
Watch Now: By the [run]Book: Episode 21
For easier tracking, check out haloreleases.remmy.dev to filter and search HaloPSA updates by ID, version, and keyword.
Forecasting in HaloPSA received a major usability improvement by automatically calculating forecasted hours from estimated project task time.
Category restrictions can now be controlled using Category Groups instead of manually configuring every category individually.
Agent Roles now support assigning cost values directly at the role level.
HaloPSA can now ignore “Unknown” scan status networks during Auvik imports.
X-Auto-Response-Suppress header to emails” can now be overridden using Action level configuration to enforce the headers when the global setting is not enabled | v2.216 #1085470 | 49:41Halo now allows email suppression headers to be configured at the Action level rather than only globally.
This setting keeps tickets selected after completing a bulk edit, allowing technicians to chain multiple bulk updates together without re-selecting tickets.
Mail Campaigns can now be grouped for organizational purposes.
Halo will now match imported Intune software records using software names instead of IDs.
Multiple Datto RMM integrations can now coexist within HaloPSA.
Halo can now automatically assign the mailbox used during outbound communication as the ticket’s default mailbox.
Snow imports now support dynamic asset type assignment.
Services can now have a separate portal-facing display name.
Asset booking functionality received multiple improvements.
The ticket timer can now be displayed as a dedicated widget on the ticket screen.
Agent Roles now support a cost field.
Ticket cloning can now be restricted to administrators.
Halo’s newer SSO framework continues to evolve.
Category restrictions can now be managed through Category Groups.
Forecasting received major usability improvements.
Audit tracking now includes Quotes and Purchase Orders.
Reporting Datasources can now display which reports rely on them.
HaloPSA now supports integration with Kaseya VSA X.
HaloPSA now integrates with SailPoint IdentityIQ.
Auvik imports can now exclude unknown scan results.
Changes to Customer Trading Names are now tracked in audit history.
Cost update logic now also supports markup calculations.
Quote approvals now support customizable messaging before signatures.
Time entry edits can now automatically rebalance contract and billed hours.
Halo introduced a safer device ID generation method.
bulkresponse=true can now be used when POSTs are made to the /fieldinfo endpoint to return a separate response for each object | v2.216 #1085574 | 47:46The /fieldinfo endpoint now supports bulk response handling.
Additional JWT validation can now be enforced for API authentication.
ConnectWise Automate alert closures can now map to configurable statuses.
X-Auto-Response-Suppress header to emails” can now be overridden using Action level configuration to enforce the headers when the global setting is not enabled | v2.216 #1085470 | 49:41Halo now supports overriding email suppression headers at the Action level.

Episode 20 of By the [run]Book dives into HaloPSA v2.214 with a mix of practical improvements and some quirky additions. Connor and Mendy walk through everything from new dollar variables and asset controls to Avalara fixes and portal enhancements—highlighting what actually matters for day-to-day MSP operations. This episode is especially useful for MSPs refining workflows, automation, and reporting accuracy in Halo.
Watch Now: By the [run]Book: Episode 20
For easier tracking, check out haloreleases.remmy.dev to filter and search HaloPSA updates by ID, version, and keyword.
Mendy and Connor noted this was very useful.
Highlighted during the user action demo as a practical workflow improvement.
Called out as a genuinely useful UI improvement.
Allows more flexibility in how incoming emails are matched to tickets.
Enables automation of asset configuration through API usage.
Introduces a new variable to output custom fields in Q&A format.
Improves visibility into asset changes over time.
Returns the email address of the user associated with a purchase order.
Enhances usability and visibility of search results in the portal.
Provides control over configuration synchronization.
Ensures correct popup behavior when multiple rules trigger.
Makes ticket source available for reporting and filtering.
Adds safeguards when configuring email matching tags.
Allows distribution lists to target all email addresses tied to a user.
Improves clarity in Avalara transaction records.
Adds control over visibility of user actions in the portal.
Improves flexibility when using Accounts and Prospects.
Enables dynamic fields based on asset lifecycle status.
Ensures asset tagging consistency during stock processes.
Adds control over Avalara synchronization scope.
Allows a predefined score for surveys.
Improves visibility when prorating billing items.
Automatically generates a ticket alongside sales orders.
Allows column width customization in list views.
Changes ordering of lists in the team view.
Adds asset status as a usable variable in buttons.
Improves flexibility when viewing lists.
Allows visual customization of buttons.
Enables distribution lists based on ticket criteria.
Adds control over forecast data ranges.
Enhances performance of Azure/Entra sync.
Improves visibility of ticket closure information.
Optimizes webhook performance and payload handling.
Refines permissions for asset management.