Three people answered the same question three different ways. What does the policy administration application cost per year? The CIO’s office said $3.1 million. The application owner said $5.4 million. Finance, working from the general ledger, said $2.2 million. Each was right about the numbers they used. None was using the same definition of the application. The list behind the cost model had been built from the configuration database, which knew about the web tier and the main database, and knew nothing about two COBOL batch programs, a shared DB2 schema, and fourteen other consumers of the same data.
IT cost allocation assigns the spend in the ledger to the applications, services, and business units that consume it. The method matters less than what it rests on. Every allocation model has two halves: money, in the form of cost pools drawn from the ledger, and consumption, in the form of drivers that measure who uses what. The money half is largely solved by finance systems and the standard TBM taxonomy. The consumption half depends entirely on application portfolio data: which applications exist, who owns them, what they contain, what they depend on, and what they use.
Where that data is rich, allocation is straightforward. Cloud estates carry tags, and tags map spend to owners. Where it is thin, as in mainframe batch, shared databases, and older services, costs get spread by headcount or flat percentages, shared components belong to nobody, and the application itself is a guess. The framework below ties each allocation decision to a named piece of portfolio data and grades how well that data supports the decision.
Allocate Costs to Real Applications
SMART TS XL shows which jobs and programs touch a shared table, with every finding linked to its source line.
FIND OUT MORE…Why Allocation Breaks at the Application Layer
Cost allocation methods are well documented: flat percentage splits, driver-based allocation, activity-based costing, and the showback and chargeback models built on top of them. The mechanics are not where models fail. A shared service rate is simply the cost pool divided by the allocation units, and any finance team can compute it. Models fail one layer lower, at the application, because every allocation lands on a cost object and the cost object is only as accurate as the application inventory behind it. If the inventory omits a program, the program’s cost lands on whichever application happens to be nearby or disappears into overhead. If shared components have no owner, their cost is spread by habit. The table lists the recurring symptoms and what they usually trace back to.
| Symptom | Usual cause in the portfolio data |
|---|---|
| Three different costs for one application | No agreed definition of which components belong to it |
| Large unallocated or overhead line | Programs, jobs, and datasets not mapped to any registered application |
| Shared platform costs spread evenly | No consumption data linking applications to the platform |
| Disputes after every showback report | Drivers that consumers cannot verify |
| Costs that stay on retired applications | Lifecycle state not tracked; dead code still counted |
| Costs that jump when someone is reorganized | Allocation tied to cost centers instead of application identity |
The Allocation Stack: From Ledger to Application
The TBM Council taxonomy organizes technology cost into four layers: cost pools, resource towers, solutions, and consumers. Spend is first classified by its nature in cost pools such as labor, software, hardware, facilities, outside services, and cloud. It is then grouped into towers such as mainframe, distributed compute, storage, network, and applications. Towers are then consumed by solutions, which include the applications and services IT delivers, and solutions are consumed by business units, products, or customers. Costs do not move between layers automatically. Each hop needs an allocation method and, for shared costs, a driver.
General ledger
| classify by nature of spend
Cost pools labor | software | hardware | facilities | outside services | cloud
| allocation method required
Resource towers mainframe | distributed | storage | network | applications | security
| allocation method required
Solutions applications and services
| usage, cost driver, or attribution
Consumers business units | products | customers
Two kinds of cost flow through this stack. Direct costs belong to one application by definition: its dedicated licenses, its named infrastructure, the labor of a team that works only on it. They need attribution, not allocation, and attribution is only as reliable as the mapping from resource to application. Shared costs serve many applications: the mainframe platform, a shared database, common utilities, the scheduler, the security stack. They need a driver that reflects how each application consumes the shared resource. The decision between direct and shared, and the choice of driver, are both questions about portfolio data.
The Application Registry: The Spine of the Model
Every allocation rule refers to an application, so the application registry is the spine of the model. A registry that holds only a name and an owner supports almost nothing. One that holds component membership, dependencies, and usage evidence supports every rule in the model. The table lists the fields an allocation model needs and where they come from in modern and legacy estates.
| Field | Why allocation needs it | Typical source | Source for legacy code |
|---|---|---|---|
| Application ID | The cost object itself | CMDB, portfolio tool | Derived from source libraries and job groupings |
| Business owner | Accountability for showback | HR, CMDB | Change history, job ownership |
| Technical owner | Escalation and data fixes | CMDB | Change history |
| Component membership | Which programs, jobs, and datasets belong to the application | Tags, deployment manifests | Source libraries, JCL, dependency graph |
| Consumers and dependencies | Basis for splitting shared services | Service maps | Dependency graph |
| Usage evidence | Driver for usage-based pools | Telemetry, sign-on logs | Job execution records |
| Data classification | Retention and compliance cost | Data catalog | Field definitions in record layouts |
| Lifecycle state | Stops costs landing on retired applications | Portfolio tool | Dead-code and zero-use analysis |
The legacy column is the one most programs leave blank. In a COBOL estate, component membership is not a tag on a resource. It is a fact derived from which programs a job runs, which copybooks they include, and which datasets they read and write.
Choosing Drivers From Portfolio Data
An allocation driver is a measure used to distribute a shared cost, and the guidance is consistent: choose drivers that reflect actual consumption, not political convenience. Cost per user suits user-driven services and is not a universal rule. The catalog below pairs each common cost pool with a candidate driver and the portfolio data needed to compute it. Without the data in the third column, the driver in the second is an aspiration.
| Cost pool | Candidate driver | Portfolio data needed | Note |
|---|---|---|---|
| Mainframe CPU and software | CPU seconds by job, weighted toward the peak window | Job to program to application map, CPU records | Software charges are commonly tied to peak rolling four-hour consumption, so peak-window CPU is fairer than total CPU |
| Shared DB2 platform | Weighted table accesses | Program-to-table read and write access mapped to applications | Weight writes above reads |
| Storage | Allocated dataset size | Dataset-to-application ownership | Datasets with no owner flagged, not spread |
| Batch scheduler and operations | Job count and job runtime | Job-to-application map | Cheap to compute once jobs are mapped |
| Shared utilities and copybooks | Dependent program count | Dependency graph | Fan-in weighted split, covered below |
| Application support labor | Ticket or incident count | Service tickets tagged by application | Needs consistent application naming |
| Development labor | Change volume | Promotions or commits per application | Reflects effort, not size |
| SaaS licenses | Named users or seats | Licensing data | Usually direct attribution |
| Cloud services | Tagged consumption | Tags | Tag coverage governs quality |
The mainframe row repays attention. Allocating CPU cost by total consumption penalizes steady daytime users and rewards the applications whose heavy batch runs happen to land in the peak window, which is the part of the curve that drives the bill. A driver built from job-level CPU during the peak window, mapped to applications through the job-to-program relationship, aligns the cost with what causes it.
Allocating Shared Components With the Dependency Graph
Shared components are where flat splits do the most damage. A shared customer master, a common date routine, or a utility program may be maintained by one team and used by dozens of programs belonging to many applications. An equal split charges a small reporting application the same amount as the billing system that depends on the component forty-one times over. A dependency-weighted split uses the dependency graph as the driver: each consuming application bears a share proportional to how many of its programs depend on the component.
Application share of shared pool
= pool amount x (application's dependent programs / total dependent programs)
The illustrative example below allocates a $360,000 annual pool for a shared customer master service across five consuming applications.
| Application | Dependent programs | Equal split | Dependency-weighted | Difference |
|---|---|---|---|---|
| Billing | 41 | $72,000 | $147,600 | +$75,600 |
| Claims | 28 | $72,000 | $100,800 | +$28,800 |
| Policy Admin | 19 | $72,000 | $68,400 | -$3,600 |
| Reporting | 8 | $72,000 | $28,800 | -$43,200 |
| Collections | 4 | $72,000 | $14,400 | -$57,600 |
| Total | 100 | $360,000 | $360,000 | $0 |
Both methods sum to the pool, which is the first rule of any allocation. The weighted method moves $57,600 away from Collections, which barely touches the service, and onto Billing, which depends on it most. The result also carries a built-in incentive: an application that reduces its dependence on the shared component reduces its share, and the saving is visible in the next report.
python
def allocate(pool_amount: float, drivers: dict) -> dict:
total = sum(drivers.values())
shares = {app: round(pool_amount * v / total, 2) for app, v in drivers.items()}
# correct rounding drift so the allocation always sums to the pool
drift = round(pool_amount - sum(shares.values()), 2)
largest = max(shares, key=shares.get)
shares[largest] = round(shares[largest] + drift, 2)
assert round(sum(shares.values()), 2) == round(pool_amount, 2)
return shares
allocate(360000, {"Billing": 41, "Claims": 28, "PolicyAdmin": 19,
"Reporting": 8, "Collections": 4})
Orphans, Dead Code, and Dark Cost
Some costs have no application at all. Programs, datasets, and jobs that belong to no registered application, and dead code that still occupies storage, build effort, and scanning licenses, form what can be called dark cost. Shared and orphaned resources are the ones that slip through even in well-governed cloud models, and in legacy estates they can be a substantial share of platform spend.
The temptation is to spread dark cost across all applications so the model reconciles neatly. That hides the problem and charges innocent consumers for it. A better treatment has three parts. Show dark cost as an explicit unallocated line in every report, so it stays visible. Assign each orphan an owner or a disposition, which feeds directly into application rationalization. And track the unallocated share over time as a quality measure of the model itself, since a falling ratio means the application registry is improving.
Showback or Chargeback: A Readiness Test
Showback reports the technology cost each business unit consumes. Chargeback moves that cost into the unit’s budget or profit and loss. Showback builds trust, and chargeback changes behavior, but chargeback on weak data produces disputes that cost more than the allocation is worth. The readiness test below gives starting thresholds that should be adjusted to the organization.
| Test | Showback threshold | Chargeback threshold |
|---|---|---|
| Share of cost allocated by direct attribution or a verified driver | 80 percent | 95 percent |
| Share of spend covered by the application registry | 90 percent | 98 percent |
| Drivers verifiable by consumers | Optional | Required |
| Consumers can influence their consumption | Not required | Required |
| Dispute process defined and staffed | Optional | Required |
| Allocation reconciles to the ledger | Required | Required |
Costs that consumers cannot control, such as security mandates and disaster recovery, are commonly kept in showback even when other costs move to chargeback, because billing a team for a cost it cannot influence creates friction without changing behavior.
Writing the Policy Down: Rules and Reconciliation
An allocation rule that exists only in a spreadsheet formula cannot be reviewed, versioned, or audited. Expressing each rule as a policy file makes the driver, its data source, its refresh trigger, and its treatment of unowned items explicit.
yaml
allocation_policy:
pool: shared_customer_master_service
annual_cost: 360000
method: driver_based
driver:
name: dependent_program_count
source: dependency_graph
refresh: on_promotion
consumers: application_registry
unowned_treatment: show_as_unallocated # never spread silently
confidence:
minimum_driver_coverage: 0.95
review_triggers: [new_consumer, retirement, major_dependency_change]
reconciliation: allocation_total_equals_pool_total
A coverage query turns the quality of the model into a number that can be tracked and reported alongside the allocations.
sql
-- How much cost is allocated by evidence versus plug
SELECT
allocation_basis, -- DIRECT, DRIVER, PLUG, UNALLOCATED
SUM(allocated_amount) AS amount,
ROUND(100.0 * SUM(allocated_amount) /
SUM(SUM(allocated_amount)) OVER (), 1) AS pct_of_total
FROM allocation_result
GROUP BY allocation_basis;
Keeping Allocation in Step With the Portfolio
An allocation model drifts the moment the portfolio changes. A new dependency shifts every shared split that involves it. A retirement should release a cost pool, not leave it parked on a dead application. A reorganization should change who receives a showback report without changing what the application costs. The table lists the portfolio events that must trigger an allocation update.
| Portfolio event | Effect on allocation | Action |
|---|---|---|
| New application onboarded | New cost object | Register, attribute direct costs, assign drivers |
| Dependency added or removed | Shared splits shift | Recompute weights on promotion |
| Application retired | Costs should fall to zero | Verify retirement, release the pool |
| Ownership change | Showback recipient changes | Update the registry |
| Consolidation of two applications | Cost objects merge | Merge history, restate baselines |
The same cost-per-application figures feed the rest of the portfolio program. They supply the total cost of ownership dimension in rationalization scoring, the baseline for modernization business cases, and the unit costs, such as cost per policy or per claim, that finance uses to judge whether a change paid off.
Frequently Asked Questions
What is the difference between cost allocation and cost attribution? Attribution assigns a cost that belongs to one application directly, such as a dedicated license. Allocation distributes a shared cost across several applications using a driver. Most models need both, and the split between them is itself a quality measure.
Which allocation method is best? There is no universal answer. Percentage splits suit small, low-stakes pools. Driver-based allocation suits shared services where consumption can be measured. Activity-based costing suits labor-heavy services. The method should match the data available, and the data is where most models are weakest.
How do you allocate mainframe costs to applications? Map jobs to programs and programs to applications, then use job-level CPU, weighted toward the peak window where software charges are driven, as the driver for platform cost. Allocate shared databases by weighted table access and shared components by dependent-program counts.
Can allocation work without a configuration database? It can, but the application registry has to come from somewhere. For legacy code, derive component membership and dependencies from source and job schedules and reconcile them with whatever records exist.
How SMART TS XL, ASK AI, and the MCP Connector Supply the Consumption Data
SMART TS XL supplies the structural half of the consumption data this model needs, and its ASK AI and MCP Connector capabilities decide how widely that data can be used across finance, architecture, and operations.
Enterprise search across languages builds the component side of the application registry: it indexes COBOL, JCL, Java, Python, and the relationships between them, so programs, jobs, and datasets can be grouped into applications and the unmapped remainder identified as dark cost. JCL expansion and job mapping resolves which programs each job step runs and which datasets it touches, which is the link between job-level CPU records and applications that the mainframe CPU driver needs. Application dependency mapping produces the dependent-program counts and the program-to-table access relationships that drive shared component and shared database splits, refreshed as the estate changes. Legacy modernization analysis identifies dead and unreachable code, so costs are not allocated to programs that no longer run. Structural impact analysis shows which applications a proposed dependency change will move cost between, so a modernization decision can be priced before it is made.
ASK AI over verified context lets finance, architecture, and operations ask the mapping questions in plain language against a scoped, verified result set. A question such as which jobs and programs touch a given table becomes a driver definition, and a saved, parameterized prompt can be rerun each quarter as part of the allocation refresh. Findings stay linked to the source lines they came from, so a consumer who disputes a driver can be shown the programs behind it. The SMART TS XL MCP Connector makes the same answers available inside approved assistants such as ChatGPT, Claude, Copilot, Gemini, and Grok, so a FinOps analyst can check which applications read a dataset without leaving the tool they already use. Access is read-only, authenticated, and role-based.
| Allocation need | Portfolio data | Capability that supplies it |
|---|---|---|
| Application registry components | Programs, jobs, datasets grouped by application | Enterprise search |
| Mainframe CPU driver | Job to program to application map | JCL expansion and job mapping |
| Shared component split | Dependent program counts, table access | Application dependency mapping |
| Dead code exclusion | Unreachable programs | Legacy modernization analysis |
| Pricing a change | Applications affected by a dependency change | Structural impact analysis |
| Driver questions and disputes | Source-linked answers in plain language | ASK AI and the MCP Connector |
Two boundaries keep the scope accurate. SMART TS XL does not hold ledger data, contracts, or invoices, and it does not meter CPU or collect usage telemetry. Those inputs come from finance systems, license records, and platform monitoring. It supplies the mapping between resources and applications and the dependencies between applications, which is the half of the model that ledgers and tags cannot provide.
A Cost Model Is Only as True as Its Application List
The three answers at the start of this article were not an arithmetic problem. They were a definition problem, and definition problems are solved with data about what an application contains and what depends on it. Better formulas applied to the same incomplete list would have produced three more disagreeing numbers.
Tie every cost pool to a named driver, tie every driver to portfolio data, grade the coverage, show the dark cost, and let the allocation follow the portfolio as it changes. Do that, and the number a CIO, an application owner, and a finance lead quote for the same application starts to converge, because they are finally counting the same thing.


