Application Portfolio Allocation Models

IT Cost Allocation Models Tied to Application Portfolio Data

IN-COM November 9, 2026 , , ,

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.

SymptomUsual cause in the portfolio data
Three different costs for one applicationNo agreed definition of which components belong to it
Large unallocated or overhead linePrograms, jobs, and datasets not mapped to any registered application
Shared platform costs spread evenlyNo consumption data linking applications to the platform
Disputes after every showback reportDrivers that consumers cannot verify
Costs that stay on retired applicationsLifecycle state not tracked; dead code still counted
Costs that jump when someone is reorganizedAllocation 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.

FieldWhy allocation needs itTypical sourceSource for legacy code
Application IDThe cost object itselfCMDB, portfolio toolDerived from source libraries and job groupings
Business ownerAccountability for showbackHR, CMDBChange history, job ownership
Technical ownerEscalation and data fixesCMDBChange history
Component membershipWhich programs, jobs, and datasets belong to the applicationTags, deployment manifestsSource libraries, JCL, dependency graph
Consumers and dependenciesBasis for splitting shared servicesService mapsDependency graph
Usage evidenceDriver for usage-based poolsTelemetry, sign-on logsJob execution records
Data classificationRetention and compliance costData catalogField definitions in record layouts
Lifecycle stateStops costs landing on retired applicationsPortfolio toolDead-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 poolCandidate driverPortfolio data neededNote
Mainframe CPU and softwareCPU seconds by job, weighted toward the peak windowJob to program to application map, CPU recordsSoftware charges are commonly tied to peak rolling four-hour consumption, so peak-window CPU is fairer than total CPU
Shared DB2 platformWeighted table accessesProgram-to-table read and write access mapped to applicationsWeight writes above reads
StorageAllocated dataset sizeDataset-to-application ownershipDatasets with no owner flagged, not spread
Batch scheduler and operationsJob count and job runtimeJob-to-application mapCheap to compute once jobs are mapped
Shared utilities and copybooksDependent program countDependency graphFan-in weighted split, covered below
Application support laborTicket or incident countService tickets tagged by applicationNeeds consistent application naming
Development laborChange volumePromotions or commits per applicationReflects effort, not size
SaaS licensesNamed users or seatsLicensing dataUsually direct attribution
Cloud servicesTagged consumptionTagsTag 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.

ApplicationDependent programsEqual splitDependency-weightedDifference
Billing41$72,000$147,600+$75,600
Claims28$72,000$100,800+$28,800
Policy Admin19$72,000$68,400-$3,600
Reporting8$72,000$28,800-$43,200
Collections4$72,000$14,400-$57,600
Total100$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.

TestShowback thresholdChargeback threshold
Share of cost allocated by direct attribution or a verified driver80 percent95 percent
Share of spend covered by the application registry90 percent98 percent
Drivers verifiable by consumersOptionalRequired
Consumers can influence their consumptionNot requiredRequired
Dispute process defined and staffedOptionalRequired
Allocation reconciles to the ledgerRequiredRequired

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 eventEffect on allocationAction
New application onboardedNew cost objectRegister, attribute direct costs, assign drivers
Dependency added or removedShared splits shiftRecompute weights on promotion
Application retiredCosts should fall to zeroVerify retirement, release the pool
Ownership changeShowback recipient changesUpdate the registry
Consolidation of two applicationsCost objects mergeMerge 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 needPortfolio dataCapability that supplies it
Application registry componentsPrograms, jobs, datasets grouped by applicationEnterprise search
Mainframe CPU driverJob to program to application mapJCL expansion and job mapping
Shared component splitDependent program counts, table accessApplication dependency mapping
Dead code exclusionUnreachable programsLegacy modernization analysis
Pricing a changeApplications affected by a dependency changeStructural impact analysis
Driver questions and disputesSource-linked answers in plain languageASK 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.