Most MSPs know they're losing money somewhere in their billing process. They just can't prove it, which makes it uniquely frustrating. You can feel the margin shrinking, but the spreadsheets look fine on the surface.
The culprit is usually sitting in your Autotask configuration items: devices that are actively managed by your team, generating tickets, consuming technician time, and never appearing on an invoice. It's not a software problem. It's a process gap that most MSPs don't realize exists until they do their first real audit.
Here's what's happening, why it's common, and how to fix it.
When a device gets added to Autotask, whether through your RMM tool or a technician creating it manually, it shows up in your configuration items list. That's step one. Step two, associating that device with a contract, is a separate step. And it's optional.
That flexibility is useful, but it also means the step can be missed.
Autotask's Device Discovery Wizard makes this clear: contract association isn't required, but when you associate a device with a contract, billing for all tickets tied to that device is automated. Optional in the technical sense. Essential in the business sense.
The challenge is that device creation and contract association often happen at different times, by different people, unless your process ties them together. A technician onboards a new workstation at 4:45 PM on a Friday, creates the device record to close the ticket, and moves on. The contract association step never happens. That device starts generating tickets. Your team works on it for the next 18 months and invoices exactly zero dollars for the managed service it's consuming.
Multiply this by a mid-size client with regular device turnover, and you're looking at meaningful revenue that simply evaporates.
Autotask can fully automate device billing, as long as the complete configuration chain is in place. Many MSPs set up part of it and assume the rest follows automatically.
The full chain, as described in the Autotask documentation on automating billing for devices, requires four components working together:
The billing rules are where the automation closes the loop. They run on a schedule, count how many devices for that customer are associated with the relevant billing product, and generate charges accordingly. If the contract association is missing, the billing rules can't see those devices. They never get counted, and charges never get generated.
The automation is working exactly as designed. The design just requires that every device be associated with a contract.
Here's where it gets more nuanced. Not all contract types work the same way during device association.
When you use the Device Discovery Wizard to associate a device with a contract and that contract is a Recurring Services contract, Autotask requires you to also specify a service or service bundle. You can skip the field while moving through devices, but you must complete it before exiting the wizard page.
If you select a Recurring Services contract but don't have the correct service or bundle set up, you won't be able to finish that wizard page. Some teams work around this by selecting whatever contract is available, including the wrong type, just to get through. Now the device is technically "associated" with a contract, but the billing rules on your fixed price contract aren't looking at it, because the device isn't tied to the right contract.
For fully automated device billing using billing rules, the contract type needs to be a fixed price contract (no milestones). The billing rules live there, they count devices, and they generate charges. A Recurring Services contract handles billing differently, through unit counts tied to services, which is a separate model entirely.
Before assuming your device billing is working, audit this:
One mismatched contract type and the billing chain can't do its job.
Catching unassociated devices after the fact is painful. Building a process that surfaces them before the billing cycle closes is straightforward, though it requires some intentional setup.
Step 1: Run a configuration item report filtered by contract
Export your active devices and filter for records where the associated contract is blank. This is your immediate gap list. Any device with no contract association is a billing exposure. Prioritize by client size and device count.
Step 2: Set up billing product associations with broad coverage
Autotask allows you to create automated billing product associations that fire when a device is created (not when edited). Set these up by device type at minimum. This ensures any new device gets a billing product assigned automatically, even if the contract association is handled separately. It also means you can identify devices with a billing product but no contract, which narrows your audit target considerably.
Step 3: Flag the gap with a notification
Set up an alert that triggers when a configuration item is created or modified and the contract association field is empty. Route a notification to your billing admin or create an internal ticket assigned to whoever handles contract setup. This makes the gap visible within hours instead of months.
Step 4: Review Contract Billing Rule Upcoming Instances regularly
Autotask provides a Contract Billing Rule Upcoming Instances page that lists up to 1,000 upcoming billing rule executions. Review this before each billing cycle. If a client has devices you know are under management but they're not showing up in upcoming charges, something in the chain needs attention. This page is your pre-invoice sanity check.
Step 5: Establish a monthly reconciliation process
Compare your RMM tool's active device list for each client against the devices showing up in Autotask billing rule charges for that client. Discrepancies are your margin leak. A 30-minute monthly review catches problems before they compound over quarters.
Audits fix past problems. Process changes prevent future ones.
The cleanest fix is making contract association part of your onboarding and offboarding checklists, not a step someone might remember to do. When a technician adds a device, the checklist doesn't close until the contract association is confirmed. Because Autotask intentionally keeps contract association flexible, a clear process is the most reliable safeguard.
If your team uses RMM tools that push devices into Autotask automatically, run the Device Discovery Wizard on a scheduled basis rather than treating it as a one-time onboarding tool. Each pass through the wizard gives you the opportunity to associate newly discovered devices with the correct contracts before they rack up untracked managed service time.
For MSPs managing 20 or more clients, consider creating a master contract template under your own organization with billing rules pre-configured for every billing product. When you onboard a new client, copy the master contract, activate the relevant billing rules, and you're starting from a complete configuration rather than building from scratch each time.
The devices are in Autotask. The contracts are in Autotask. The automation exists to connect them. The only thing missing is the process discipline to make sure the connection actually happens.
Device billing gaps are a process issue, not a software issue. They come from a two-step process where step two doesn't get enforced. Fix that, and you stop the margin leak at the source.
Every ticket on a billable device should be worked by the right technician, fast. Once your billing is airtight, Rocketship helps make sure the tickets on those devices are triaged, dispatched, and scheduled automatically in Autotask, so your team spends its time on billable work instead of ticket shuffling. Need help auditing your contracts and device billing? Our Autotask Consulting team can help, or grab the free Autotask Data Clean-Up Kit. You can also schedule a demo of Rocketship.