Most automation programmes can say how many bots they run. Few can say how many hours those bots sat idle last month, how many attended seats belong to people who have changed role, or what the programme pays per completed transaction. Licensing is usually the largest recurring cost in an automation budget, and it is usually renewed on last year's count plus a margin. This post is about turning that line into something that is measured, reviewed and right-sized.
Where the money goes.
Licence shapes differ by vendor, but the same five recur. Unattended runtimes are priced per concurrent bot. Attended licences are priced per named or concurrent user. Document processing is metered in pages or units. Non-production machines carry their own entitlements. Add-on modules are bundled at purchase. Each shape wastes money in its own way.
| Licence shape | How it is wasted | What to measure |
|---|---|---|
| Unattended runtime | Scheduled for one window a day, idle for the other twenty hours | Busy minutes per runtime per week |
| Attended seat | Assigned to a person who changed role, moved team or left | Days since last run, per user |
| Document processing units | Bought for the peak month, consumed at the average month | Units consumed against entitlement, monthly |
| Non-production runtime | Development and test machines licensed like production | Builds and test runs per month |
| Add-on module | Enabled at purchase, never configured | Any activity at all |
Measure before you negotiate.
Every major platform exposes the data. UiPath Orchestrator records job start and end times per robot. Automation Anywhere Control Room and Blue Prism Control Room keep session history. Power Automate reports desktop flow runs per machine. Export the job history for the last ninety days and compute three figures for every licence you hold.
- Utilisation. Busy minutes divided by available minutes, per runtime, per week. Count weekday working hours for attended seats and all hours for unattended runtimes.
- Peak concurrency. The largest number of runtimes busy at the same moment, per hour of the day. This is the number that decides how many unattended licences the programme needs. The count of robots is irrelevant.
- Cost per transaction. Licence cost allocated to a process, divided by items completed. Finance understands this figure. A count of fourteen bots tells them nothing.
Expect surprises. A common pattern is a dozen unattended runtimes all scheduled between six and nine in the morning so that reports are ready before the business day, idle for the remaining hours, while peak concurrency never passed five. Another is an attended licence list that has not been reconciled with the HR leaver report since the first rollout.
Right-sizing without breaking the schedule.
Pack the schedule.
Spread jobs across the full window the business allows. Many processes that run at seven in the morning could run at two. Queue-based designs help here, because one runtime can work through several work queues in sequence instead of several runtimes each waiting for their own trigger. Respect hard dependencies. A reconciliation that must finish before the branch opens cannot move. Agree the windows with the process owners, write them into the solution design document, and let the orchestrator do the packing.
Share runtimes across processes.
A runtime dedicated to a single process is a habit from the first project. Once the bot framework handles credentials, assets and queues cleanly, one machine can serve several processes through the day. Keep dedicated runtimes only where a process is time-critical or where the target application's own licensing ties a session to a fixed identity.
Reclaim attended seats.
Run a joiner-mover-leaver check against the attended licence list every month. Reassign seats that have not run an attended bot in sixty days. Where the vendor offers concurrent attended licensing and the users work in shifts, the switch from named to concurrent often halves the seat count on its own.
Treat non-production separately.
Development and test machines rarely need production-grade entitlements. Use the vendor's non-production or developer licences where they exist, pool test runtimes across teams, and switch off anything that has not run a build or a test in a quarter.
Report it the way finance reads it.
A licence report that lists robot names helps nobody outside the automation team. Report by process and by business unit. Show capacity headroom as well, because the next question from finance is whether the new automations in the pipeline will need new licences. Once the schedule is packed, they often do not. The monthly pack needs five lines.
- Allocated licence cost per process and per business unit.
- Cost per completed item, with the trend over the last six months.
- Peak concurrency against licensed capacity, so headroom is visible.
- Seats reclaimed and runtimes released this period, with the saving they represent at renewal.
- Renewal date, recommended quantities and the reasoning behind them.
Who owns it.
In a managed automation service, licence utilisation is a standing item in the monthly service review, next to the SLAs and the exception backlog. In an in-house CoE, give it to the platform lead and put the report in the pack the steering committee already reads. The effort is small once the export and the calculation are scripted. The saving at renewal is usually the easiest money a programme ever finds, and the credibility it earns with finance is worth more than the saving.
An idle licence is a cost without a transaction. Count the hours, then renew for what you use.