Quoting Software for MSPs: Recurring & Per-Device

Quoting software for MSPs has to do three different jobs in one quote: price the recurring managed-services agreement, calculate the per-device and per-user tiers underneath it, and cost any one-off project or onboarding work alongside — then hand the signed result into your PSA as a contract and a schedule without anyone re-typing it. That combination is what makes MSP quoting genuinely awkward. Most quoting tools are built for a single transaction — one product, one price, one sale — and an MSP quote is really three quotes stapled together, each with a different unit of pricing and a different life after it’s signed.

The result is the thing every operations lead in a managed-services shop recognises: the recurring bit gets priced in the PSA, the project bit gets priced in a spreadsheet, the actual proposal gets built in a doc or a slide, and three numbers that should match rarely do. This post is about what MSP quoting actually needs to hold together, where the money leaks when it doesn’t, and the honest point where a bolt-on tool stops being enough. For the general principles, the hub is quoting software best practices — here we’re on the MSP-specific mess.

Key Takeaways

An MSP quote is three quotes in one: recurring managed services, per-device or per-user tiers, and one-off project work — and most quoting tools only handle one of the three cleanly.
The PSA tie-in is where it breaks: if the quote doesn’t flow into the PSA as a contract and billing schedule, someone re-keys it, and re-keyed device counts are where recurring revenue quietly leaks.
Per-device pricing needs to reconcile to reality — quoting 40 seats and billing 40 while the client actually runs 55 endpoints is money left on the table every single month.
Recurring is where the real value sits, so a quote that mis-scopes the monthly by £200 costs you that every month for the contract’s life, not once.
The gap isn’t “MSP quoting software” versus “no software” — it’s the space between a PSA’s quoting bolt-on and a general CPQ tool, where the honest fix is usually one system that reconciles the quote, the device count and the billing.

Why an MSP Quote Is Three Quotes in One

Sell a widget and the quote is simple: price times quantity, done at the point of sale. An MSP sells nothing that clean. A single new-client proposal usually carries a monthly recurring managed-services fee, a per-unit layer under it (per device, per user, per server, per mailbox — often several at once), and a one-off project to get there: onboarding, migration, hardware, the first-month heavy lift.

Each of those prices differently and behaves differently after signature. The recurring becomes a billing schedule that runs for years. The per-unit layer has to be counted, and re-counted as the client grows or shrinks. The project is a fixed or T&M job with its own margin that has nothing to do with the monthly. A quoting tool that treats all three as flat line items on one document will let you produce the quote — but it won’t keep the three honest against each other, and that’s where the trouble starts.

Per-Device and Per-User Pricing: Where the Count Drifts

Per-device and per-user pricing is the MSP standard for a reason — it scales with the client and it’s easy to explain. It’s also where quotes quietly go wrong, because the count on the quote and the count in reality drift apart the moment the ink dries.

You quote 40 workstations and 3 servers. Six months in the client’s hired eight people, added a NAS and two more VMs, and nobody re-quoted. Your tools are managing 53 endpoints; your invoice still says 43. Operators tell us this is one of the most common leaks in the whole model — not fraud, not a bad deal, just a device count that was captured once at quote time and never reconciled against what the RMM actually sees.

The point-of-view OpsMavix will stand behind: for an MSP, the quote is not the end of pricing, it’s the start of a reconciliation loop. The number you quote has to be checkable against the number you manage, forever. A quoting tool that can’t close that loop is handing you a monthly leak dressed up as a signed deal.

The Recurring Line Is Where the Margin Really Lives

On a one-off sale, a £200 pricing mistake costs you £200. On an MSP recurring line, a £200-a-month scoping error costs you £200 every month until someone renegotiates — £2,400 a year, £7,200 across a typical three-year agreement, on one client. That asymmetry is the whole reason MSP quoting deserves more discipline than product quoting, not less.

It cuts both ways. Under-scope the monthly and you carry the loss for years. Over-scope it to be safe and you lose the deal to an MSP who priced it tighter. Getting the recurring right means building it from the actual cost to serve — the per-device tooling cost, the expected ticket load, the SLA overhead — not from a gut round number. That’s a job for a rate structure the quote assembles from, the same discipline the general quoting software best practices guide lays out, applied to a monthly instead of a one-off.

The PSA Tie-In: Where the Quote Goes to Die

Here’s the specific failure that makes MSP quoting worse than most: the quote and the system that bills it are usually two different tools. You win the deal, and now someone has to turn the quote into a contract in the PSA, a billing schedule with the right recurring lines, and a project with the onboarding tasks. If that’s a re-key, three things go wrong.

The device counts get transposed wrong. The recurring line gets rounded or fat-fingered. And the project scope in the proposal doesn’t match the project created in the PSA, so the team delivers against a different spec than the client signed. A wholesale-style re-keying problem, except here the thing being re-typed is a multi-year revenue schedule.

A quote that flows straight into the PSA as contract, schedule and project — no human retyping the numbers — is the difference between a quote that’s a document and a quote that’s the origin of your billing. This is exactly the kind of join that turns a stack of tools into one operating picture, the same problem an operations dashboard or reconciliation layer is built to solve: making the quote, the device count and the billing show the same number without a human forcing them to agree.

Recurring, Per-Device and Projects in One View

The reason MSPs end up with three tools and a spreadsheet is that no single quoting product is happy holding all three shapes at once. The PSA quotes recurring well but treats projects as an afterthought. A project-quoting or quoting and estimating software tool costs the one-off work well but has no concept of a per-device monthly. A general CPQ tool does neither in MSP language. So the recurring lives here, the project lives there, the proposal is assembled somewhere else, and reconciling them is a manual job nobody enjoys or does consistently.

What an MSP actually needs from quoting is narrower and harder than “make a nice PDF.” It needs the recurring, the per-unit tiers and the project priced in one place, from one rate structure, so the three numbers are guaranteed to agree on the document the client signs. It needs the per-device count to be reconcilable against what the tools manage, so the quote doesn’t silently go stale. And it needs the signed result to land in the PSA as billing and delivery without a re-key. That’s less a quoting feature and more a small operating system for how an MSP turns a proposal into revenue — closer in spirit to micro estimating discipline than to a document generator.

Build, Buy, or Own the System — the Honest Take

Don’t build anything you can buy that fits. If your PSA’s native quoting handles your recurring and per-device cleanly, and your projects are simple enough to live in it too, use it and stop reading — the method matters more than the machinery, and a disciplined quote in a tool you already pay for beats a custom anything used sloppily.

The honest case for a right-sized system you own is narrower and specific: you’re running recurring in the PSA, projects in a spreadsheet and proposals in a doc; the three never quite match; your device counts drift out of sync with what you actually manage; and the quote-to-PSA handoff is a re-key that occasionally costs you a mispriced multi-year line. At that point the leak has a number on it — the under-counted endpoints, the stale monthlies, the projects delivered against a spec that doesn’t match the sale — and it’s usually bigger than the cost of joining the pieces into one system that reconciles them. Not an enterprise CPQ suite built for a software vendor ten times your size, and not another bolt-on that only quotes one of your three shapes. One system, shaped to how an MSP actually prices and bills, that you own.

If you’re not sure whether your quoting is leaking or just annoying, that’s the thing to find out first. The difference between “three tools that don’t talk” and “a monthly revenue leak you can’t see” is a number, and it’s usually worth putting on paper before you decide whether to fix the process or build the system.