Creating Interunit Models for Shared Services

What happens if you need several models for shared services? For example, suppose that your business unit has two production sites and a central administrative office supporting the two production sites. In traditional activity-based costing, the only way to model this is by making a single, large model for the entire business unit. This makes the scope of the project large and complicated. However, with Activity-Based Management, you can use an interunit, shared-service model to address this business requirement.

Activity-Based Management lets you cost services provided by a shared-services business unit or a shared-services group into a separate model. After you determine these shared-services cost objects, assign those costs to other models within or outside the same business unit.

Perhaps one of the shared services, provided by the example's central administrative office, is the human resources function. Because you need to drive human resources amounts between models, while you're creating a model you make Hiring Personnel a cost object. After you finish building your model, run the model and derive a total monthly cost for the Hiring Personnel cost object.

Suppose that, for example, Site A is an older facility and does not require many new hires; in fact, Site A hired only two people last month. Site B, however, is a rapidly growing facility and hired 18 people last month. This disparity could lead you to define an interunit driver that assigns 10 percent of the cost of hiring to Site A and 90 percent to Site B. This type of driver lets you make assignments from the cost object of one business unit and model to the support activities of one or more business units and models.

You can allocate shared-service resource costs to other shared-service resources using the looping method, which can produce more accurate results because the system bases the allocation on the processes that the resource performs. Once the allocation is complete, the cost from the cost object loops to the corresponding resource and continues looping until the percentage difference between the cost resource and the corresponding cost object meets a tolerance limit or exceeds a maximum loop amount. Once reciprocal allocations are complete, the system sends final costs to a production Activity-Based Management model using the existing inter-business unit (IBU) drivers.

Understanding Reciprocal Allocation and Looping

Reciprocal allocation in Activity-Based Management models lets you allocate shared-service resource costs to other shared resources. Define a single, shared-service model that includes all reciprocal Activity-Based Management objects and activities. Once reciprocal allocations are complete, the system sends final costs to a production Activity-Based Management model using the existing IBU drivers.

Within the shared-service model, define a cost object with the same name as the resource. The system bases the allocation on the processes that the resource performs. Once the allocation is complete, the cost from the cost object loops to the corresponding resource and continues looping until the percentage difference between the cost resource and the corresponding cost object meets a tolerance limit or exceeds a maximum loop amount. You can allocate any residual cost remaining after looping is complete because the targets of residual amounts often serve as sources for further allocations.

Understanding Reciprocal Allocation Methods

Activity based costing drives overhead costs from resources to activities and then to the cost objects. Activity based costing can also drive costs directly from resources to cost objects. In scenarios where costs require allocations among resources (reciprocal allocations), activity based costing drives costs to activities only after completing allocations to the resources. For example, IT and HR resources could share costs with each other. Therefore, the actual cost of these resources can be determined only after they complete the allocation of costs to each other.

The following example shares costs between resource 'S' and resource 'T.' In addition, it allocates the resource cost of 'S' to cost objects 'U,' 'V,' and resource 'T' (40%, 40% and 20% respectively) and drives resource cost of 'T' to objects 'V,' 'W,' and resource 'S' (20%, 50% and 30% respectively).

Image: Example reciprocal allocation to share costs

This example illustrates the fields and controls on the Example reciprocal allocation to share costs.

There are two methods of performing a reciprocal allocation:

Mathematical (simultaneous equation)
Iterative

These methods are discussed below.

Mathematical Method

The following algebraic equation models our example for simplistic reciprocal allocations:

S = 100 + .3T
T = 200 + .2S

Solving for S and T gives S = $170.21 and T = $234.04.

Image: Mathematical Method

The following steps demonstrate a reciprocal allocation.

Allocate the cost of resource S to objects U, V and resource T (40%, 40% & 20% respectively).

Allocate the cost of resource T to objects V, W and resource S (20%, 50% & 30% respectively).

Iterative Method

With the iterative method, you repeat allocations until the resource amounts for S and T become negligible or zero. This method is most suited for computer applications. When the resource amounts become negligible (as defined by a tolerance limit attribute), the program exits the iterative allocation loop.

Image: Iterative Method

The following steps demonstrate an iterative allocation.

Allocate the cost of resource S to objects U, V and resource T (40%, 40% & 20%, respectively).

Allocate the cost of resource T to objects V, W and resource S (20%, 50% & 30%, respectively).

Iteration 1 starts by allocating resource costs of S ($100) and T ($200). After allocation, resources S and T have reciprocal allocation amounts of $60 and $20 respectively.

After Iteration 2, resources S and T have reciprocal amounts of $6 and $12, respectively.

We repeat the allocations until the allocating resource amounts are near zero (which occurs in Iteration 8).