You cannot manage what you cannot see. Server licensing is sold by the processor core, not the person, and usually lives in spreadsheets nobody trusts. So License Commander makes it physical: every server is a real machine, resolved on the network and reconciled against the hardware it runs on, and since September 2026 each production server is billed as its own license.
Named-user licensing is easy to picture: one license, one person. Server licensing is not. A SQL Server license is measured in processor cores, bound to a physical or virtual machine, often with a standby copy for disaster recovery, and it is almost never tracked against the actual hardware.
The result, everywhere, is a spreadsheet of server licenses that no one can reconcile against the machines in the racks. Are we over-licensed? Under-licensed? Which license covers which server? Nobody can say with confidence.
The Fleet answers that by making every server license concrete: a one-to-one map to a real machine, resolved to its true network identity, paired with its standby, and shown on a board where the gaps are obvious. Once that inventory could be trusted, it replaced the old per-unit license totals as the thing the recharge bills from.
By the numbers
every production server carries and bills its own license.
the yearly SQL total was the same after the switch to per-server billing as before it.
licensing counted the way it is sold, and split honestly across machines.
production servers and their disaster-recovery twins kept together as one entitlement.
each server verified to its true network identity, from on campus.
each server keeps its own notes, files, and saved email threads.
A license is really a machine
Every production server carries its own license.
In the Fleet, a server license is not an abstract quantity. Until September 2026, each unit’s SQL licensing was one total on a single record, with the servers tracked beside it. Now the servers are the licenses: each production server carries its own account, billing period, and price, and the recharge bills it directly. The old per-unit totals were retired in the same step, and the yearly SQL total came out exactly the same as before.
Disaster-recovery standbys, servers the university owns outright, and servers whose license comes included with the cloud host stay in the inventory at $0, outside the recharge. A new SQL license with no server recorded yet still shows in the amber “needs a server” banner until someone registers the box.
Why it is clever
The switch was made only after every unit’s servers summed to that unit’s old total, penny for penny, and the totals were checked again once the old records were gone. Editing a server never knocks it out of the bill either: its billing status is kept on every save unless someone changes it on purpose.
✓ Toil removed a spreadsheet of license quantities that maps to no actual machines, and a server bill nobody could check line by line.
Counting cores, not seats
Licensing by the processor, and splitting it correctly.
Server licenses are counted in cores, and the Fleet tracks them that way. A two-core license can legitimately cover two single-core machines, and the Fleet represents that split honestly, so the core math always balances against what was purchased.
Servers the university owns outright, or that are licensed through their cloud host, are marked with a green $0 chip and left out of the core count, so they never look like over-deployment.
Why it is clever
Getting the core accounting right is where most server licensing quietly goes wrong. By modeling cores rather than machines-as-units, the Fleet can represent the real, messy ways licenses are allocated, a license spread across servers, without ever losing the thread of how many cores were actually bought.
✓ Toil removed guessing whether the core count in the contract matches the machines in the racks.
Pairing production with its standby
Keeping a server and its disaster-recovery twin together.
Many production servers have a disaster-recovery standby, and the two are licensed as a pair. The Fleet keeps them visibly paired, labeled clearly as production and DR, so their shared licensing is obvious and neither half is ever mistaken for an independent server. An Always On availability group is the exception: every node in it is active, so every node is licensed, and the Fleet records it that way.
Why it is clever
A DR pair looks like two servers but is one licensing unit, and conflating them is a classic way to double-count. The Fleet shows the relationship explicitly, so an auditor sees a production server and its standby as the single paired entitlement they really are.
✓ Toil removed mistaking a disaster-recovery copy for a second server that needs its own license.
You cannot manage what you cannot see. The Fleet makes every server license a real machine: resolved, paired, reconciled, and billed on its own.
Finding the machine on the network
Resolving each server to its true identity, from where it can actually be seen.
A server is only real if you can find it. The Fleet resolves each machine to its fully qualified name and address, and it does that resolution from a campus machine that can actually see the internal network, because many of these servers are invisible from the outside world.
Why it is clever
The same resolver logic that anchors the Adobe device fleet runs here, from on campus, so internal-only servers the cloud cannot reach still get a real, verified identity. A name in a spreadsheet becomes a machine you can confirm is where you think it is.
✓ Toil removed a list of server names nobody can verify still point at real, reachable hardware.
A board grouped the way the money flows
One column per unit and edition, one card per server.
The Fleet Board shows every server as a card, grouped into columns by unit and SQL edition. Each column shows its server mix (production, owned, and $0 DR standbys), the yearly amount it bills, its cores, and a flag when any server in it needs a fix: a billable server with no account or no price, or a DR partner that isn’t recorded. Drop one card on another to pair a server with its standby, edit details right on the card, or add a new server in its column, where it joins the recharge with the rest of its group.
The board can be arranged the way each person likes: drag columns into a different order, hide the ones you don’t need, change the text size, and download the whole grid as a spreadsheet. The Fleet’s main roster can still group servers by unit or by fund, so who runs a machine and who pays for it are both visible.
Why it is clever
The board turns an invisible reconciliation into a visual one. A server with no account, or a standby with no partner, is not buried in a spreadsheet row; it is a flag you cannot scroll past, sitting next to the dollars it affects. The work of tying entitlements to hardware becomes something you can actually finish.
✓ Toil removed the reconciliation of licenses to servers that never gets done because it lives in a spreadsheet.
Notes that stay with the server
The email that explains a server, kept on the server.
Every server has a Notes button on both the roster and the board. It opens the server’s running notes, any attached files, and a box where an email thread can be pasted and saved as a PDF on the record. A count on the button shows when a server already has notes.
Why it is clever
Server licensing decisions often live in one email from the person who knows the box: how many cores, why it is a standby, who agreed to pay. Keeping that thread on the server means the next person doesn’t have to go looking, and it uses the same notes and attachments that orders already have.
✓ Toil removed hunting through old email to find out why a server was licensed the way it was.
Every server license, mapped to metal
A one-to-one map from server to license that the recharge now bills from directly, honest core accounting that leaves owned and included servers out, production and DR shown as the pairs they are, every server resolved to its true network identity from where it can actually be seen, a board grouped by unit and edition where the gaps are impossible to ignore, and the paper trail kept on the server itself. Server licensing stops being a spreadsheet nobody trusts and becomes an inventory you can bill from.