Resource Leveling

Resource Leveling Changes from MSP 2010 to MSP 2016 – Revisited

In a departure from an earlier study, the resource-leveled schedule generated using Microsoft Project (MSP) 2016 may sometimes be substantially shorter than the comparable schedule from MSP 2010. The result suggests a more sophisticated leveling algorithm that, while sometimes generating shorter schedules, may increase the associated resource-related risks.

Several years ago I wrote an article examining some reported differences in resource leveling behavior between Microsoft Project (MSP) 2010 and 2013 versions. In general, those observations implied that the newer software was generating longer schedules under default conditions. (The observations were by others, since at the time I was only using MSP 2010.) I concluded the article with a speculation that the leveling algorithm may have been adjusted to preserve the appearance of the pre-leveling “Critical Path,” but at the expense of a longer schedule.

A recent test case using MSP 2016 does nothing to confirm that speculation, and an opposite conclusion is implied.

Below is an idealized schedule for construction and commissioning of a small processing plant, including resource loading. Only technologically-required logic is included, so that a) the resources are all severely overallocated, and b) the schedule is unrealistic. The same schedule is shown in both MSP 2010 and MSP 2016 forms, with only cosmetic differences. There is a Deadline of 25Feb’05 on the Substantial Completion task, and no explicit risk buffers are present. [The MSP 2010 form was used to illustrate the resource-leveled critical path in a technical paper I presented at AACE International in 2017.]

To resolve the resource over-allocations and generate a more realistic schedule, the resource leveler is applied in both MSP 2010 and MSP 2016 using simple leveling options with no task priorities defined.

As shown below, these options lead to completely different schedules in the two tools, with MSP 2016 generating a leveled schedule that is 10-days shorter than the MSP 2010 version.

Key observations:

The MSP 2010 schedule failed to meet the Deadline, so more tasks are marked Critical due to zero-or-negative Total Slack. Six tasks including the two milestones have TS=-10d (i.e. the “most critical” as defined by Total Slack.)
The MSP 2010 leveler did not impose any task splits, even though they were allowed.
The MSP 2016 schedule meets the Deadline, so no negative slack is imposed. Seven tasks including the two milestones have TS=0 (the “most critical.”)
The MSP 2016 leveler imposed a task split on one task (A3 Structures).

A close look at the Resource-leveled Critical and Near Critical paths – Using the Near Longest Path Filter in our BPC Logic Filter add-in – demonstrates that MSP 2016’s leveler creates a more condensed schedule. Specifically:

MSP 2010 generates a single continuous Resource-leveled Longest Path (BPC Relative Float = 0) comprised of eight tasks in sequence. The other 12 tasks possess 10 to 70 days of relative float.
MSP 2016 generates a continuous Resource-leveled Longest Path of 13 tasks in sequence, with 2 additional tasks (and a split part of one of the original 13) in parallel branches. The other 5 tasks possess from 20 to 60 days of relative float. As a result, more of the work is both concurrent AND Critical. It turns out that the splitting of the A3 Structures task is not the key to the more condensed schedule in MSP 2016. In fact, re-running the leveler while disallowing splits leads to a schedule that – with no splits and with a completely different sequential arrangement – finishes at the same time. The corresponding Resource-leveled Longest Path is comprised of only 8 tasks in sequence, with 1 additional, parallel/concurrent task. This leveled schedule has fewer resource mobilizations and disruptions along the longest path while still finishing at the earliest leveled time; it appears to be lowest risk.

This example suggests that MSP 2016’s default resource leveling algorithm may be substantially more sophisticated than MSP 2010’s, and it promises – under the right circumstances – to offer shorter leveled schedules in the absence of explicit user-defined priorities. The shorter schedules may also be accompanied by technical and resource risks associated with multiple, concurrent branches of the resource-critical-path. Project managers using resource leveling are advised to consider and buffer these risks appropriately.

In contrast with this finding and in keeping with the prior version of this article, others have continued to observe consistently longer schedules being generated by MSP 2016 (compared to MSP 2010 and earlier), on some standardized schedule models. These observations are noted in the comments.

Inspecting Task Resource Drivers with BPC Logic Filter for Microsoft Project

BPC Logic Filter – an add-in for Microsoft Project (desktop) – includes an advanced Logic Inspector feature to greatly simplify the examination and navigation of resource-leveled, logic-driven schedule activities.

The resource leveling feature in Microsoft Project (MSP) offers an effective method for management of resource-constrained projects, but most project managers don’t appreciate its impact on Total Slack, the Critical flag, and the resulting “critical path.” Specifically, all of those terms become unreliable or misleading in the presence of resource leveling. I first wrote about those issues here.

With some improvements to BPC Logic Filter – we were able to identify resource-driving links and include them in The Resource-Constrained Critical Path and in other logical path analyses.

Analyzing logical paths in schedules requires detailed examination of each task’s dependencies and (for leveled schedules) resource assignments. It’s helpful to have the results of such examinations at hand while reviewing (and confirming) the logical path analyses, so recent versions include a task Logic Inspector for Inspecting Task Links with BPC Logic Filter.

Logic Inspector also includes inferred resource-driving links if desired by the user. Consider this simple resource-leveled schedule from the earlier articles.

With resource-checking disabled (and no calendars or constraints to confuse things), BPC Logic Filter computes relative float and identifies driving predecessors in a way that is consistent with MSP’s calculation of total slack. For the A2 Structures task (ID 11), this means that the driving predecessor is the only predecessor — ID10: A2 Civil — even though it finishes two weeks before A2 Structures starts. It also means that A2 Structures is logically driving all three of its successors.

Adding the late-relative float (LRF) column identifies the one successor relationship with bi-directional driving logic. Thus, ID14: A2 Electrical Change Order 1 is highlighted red as the successor relationship with the most effect on the total slack of the selected activity.

While this method is useful for understanding how MSP computes slack in resource leveled schedules, it does not help in understanding the actual resource limitations that drive the schedule of a task. To gain that understanding, we first visit the Tracing Preferences tab in the Settings and ensure that Resource Checking is enabled.

Now Logic Inspector shows us the true picture of the schedule of the A2 Structures task. Namely:

1. A new predecessor — the true driving predecessor for the task — is identified: the A1 Structures task in Area 1 must finish (and release its resources) before the A2 Structures task can start. The only explicit logical predecessor of the A2 Structures task — ID10: A2 Civil — has 10 days of relative float. That is, it could slip two weeks according to the standard calendar before THIS RELATIONSHIP starts to drive the A2 Structures task.

2. A new “driven successor” is identified in that the A3 Structures task may not start until the structural resources are finished with A2 Structures.

3. The A2 Electrical Change Order 1 task (ID14) is actually 40 days (8 weeks) away from being driven by its relationship to the current task. (It is in fact driven by other resource constraints.)

4. Tasks 10 and 14 remain highlighted as late-date drivers. With no direct impact on the scheduled dates for the selected task, they illustrate MSP’s basis for total slack calculations.

The JUMP button — which allows on-the-fly exploration of the schedule through logic links — treats the (implicit) resource driving links the same as explicit logical relationships. Consequently, it is just as easy to hop through the logic of most resource-leveled schedules as it is to hop through one with no resources at all.

Video – Using BPC Logic Filter to Analyze Resource-Leveled Critical Path

Here’s another video of BPC Logic Filter in action – this time revisiting the themes of previous blog entry: The Resource Critical Path

Leveling Changes from MSP 2010 to MSP 2013

[I’ve slightly edited this old article – mostly figures. After “upgrading” to Microsoft Project 2016, I can confirm that MSP 2016’s resource leveler appears similar to MSP 2013’s leveler in the simple case examined; both are substantially different from MSP 2010’s.]

Over the last few years, some tests of resource leveling algorithms in various software packages have been reported informally over at Planning Planet.

When using “default” conditions (i.e. without implementing any user-defined priority schemes), the general picture was that leveled schedules from MSP 2010 were significantly longer than those from MSP 2007. There have also been reports that MSP 2013 (and MSP 2016, which seems to use the same leveling rules) produces even longer leveled schedules than MSP 2010. Other software (Spider Project in particular) tend to produce shorter schedules under resource constraints. I haven’t paid too much attention to these reports because a) I don’t use resource leveling often, and b) when I do use leveling, I always define some specific leveling priorities, so the “default” results are not so relevant.

Last week, a French planner (“Alexandre”) on PP noted some significant changes in default leveling results when migrating a simple schedule from MSP 2010 to MSP 2013, wondering what might be the reason for the changes. I’m still on 2010, so I haven’t noticed the change in 2013. While it’s clear that Microsoft has modified the leveling rules from version to version, they don’t publish the details, so addressing the “reason for the change” is just speculation. My own speculation is that minor changes to the leveling algorithm were made to limit apparent changes to the pre-leveling “Critical Path,” even at the expense of extending the schedule. For Alexandre’s specific example:

The project has a total duration of 7.5 days, and the pre-leveling (i.e. CPM) critical path runs through task 5. Task 5 has 0 days of total slack, while task 8 has 2 days of slack.

Leveling Fig0 — Figure 0. Pre-Leveling (CPM) Schedule – 2010

In resolving the resource conflict between task 5 and task 8, MSP 2010’s default rule gives greater scheduling priority to task 5 because:
- The CPM schedule has it starting earlier;
- It has lower total slack in the CPM schedule;
- It has a longer duration;
- It comes first on the task list;
- It is marked as “Critical” (?);
- Some other factors…(?).

(I have no idea what the relative contributions of these factors are in the scoring. Some might be zero.)

- As a consequence of leveling, task 5 (the “critical” one) is scheduled first, while task 8 is delayed, and the project is extended 1 day for a total duration of 8.5 days. Total slack is re-computed after incorporating the leveling delays, and a new “Critical Path” is displayed.
  - Perversely, Task 5 – which was clearly “critical” before leveling and is also clearly a resource driver for the project completion – now has 1 day of Total Slack.
    Figure 1. Leveled Schedule – 2010
  - Task 7 is now shown as “Critical,” even though there is neither a logical nor a resource-driving reason justifying it.
  - So in short, the MSP 2010 leveling algorithm can substantially change the “Critical Path,” and the resulting slack values can be completely misleading. (I wrote about this here: Logic Analysis of Resource-Leveled Schedules (MS Project).)
  - The next figures (from BPC Logic Filter) illustrate the actual resource-constrained Longest Path (Fig. 2) and Multiple Float Paths (2a) through the 2010 schedule.

Leveling Fig2 — Figure 2. Resource-Constrained Longest Path of Leveled Schedule – 2010

Resource-Constrained Multiple-Float Paths of Leveled Schedule - 2010 — Figure 2a. Resource-Constrained Multiple-Float Paths of Leveled Schedule – 2010

In contrast, MSP 2013 task gives greater scheduling priority to task 8, delaying task 5. I suspect this is driven by some complex tuning of the leveling rules around Total Slack.
- Alexandre provided the MSP 2013 leveled schedule here (which also includes a minor date shift).
  Figure 3. Leveled Schedule – 2013
- I’ve repeated it below in my [MSP 2016 model using Standard leveling order.] The resulting “Critical Path” appears essentially the same as the pre-leveling version, but with an added 3-day leveling delay before task 5. This may give project managers confidence that the leveling exercise has not “screwed up” their critical path.
  Figure 4. Leveled Schedule – 2016
  
  Unfortunately, the project finish has been extended by an additional 2 days compared to the MSP 2010 leveler. It is now 10.5 days.

- The project manager’s confidence in the critical path is still misplaced. Task 7 and task 8 are now shown as far from critical, with 5 days of total slack. As shown in the next two figures from BPC Logic Filter, however, they are obviously on the resource-constrained longest path through the schedule.

Figure 5. Resource-Constrained Longest Path of Leveled Schedule – 2016

Figure 5a. Resource-Constrained Multiple-Float Paths of Leveled Schedule – 2016

Comparing the 0-Float Paths of the two schedules (Figures 2a and 5a), we see that unlike MSP 2010, MSP 2013 and MSP 2016’s leveling engine has preserved the logic drivers from the pre-leveling CPM schedule while implicitly inserting task 7 and task 8 into the driving path to project completion. Although the project is extended as a result, the appearance of a stable critical path is preserved. Fortunately, BPC Logic Filter depicts the resulting resource-constrained critical path clearly in both cases.

My speculation on the reason for the changed algorithm is based on the Project development team’s demonstrated preference for the appearance of stability (for mid-level users) over behavior that might be more technically correct from an advanced user’s point of view. (See the handling of inactive tasks in MSP 2013 for another example.)

For an update on this topic, see Resource Leveling Changes from MSP 2010 to MSP 2016 – Revisited

The Resource Critical Path – Logic Analysis of Resource-Leveled Schedules (MS Project), Part 2

BPC Logic Filter for Microsoft Project provides an automated method for extracting and presenting the Resource Critical Path (a.k.a Resource-Constrained Critical Path or Critical Chain) from a leveled schedule.

In a previous entry (Logic Analysis of Resource-Leveled Schedules), I investigated the impact of resource leveling on the logical analysis of Microsoft Project schedules. Conclusions were not encouraging, i.e.:

Project’s Total Slack calculation – and as a consequence, the “Critical” flag – fails to adequately account for resource constraints in the schedule. Neither the “Resource Critical Path” nor any other resource-leveled logical path can be deduced from the schedule by analyzing the logical relationships and slack (nor even the “Leveling Delay” artifacts). Even worse, tasks that are clearly schedule critical when considering resource constraints can have unexpectedly high values for Total Slack and may therefore be neglected during crashing exercises or disruption analysis.
BPC Logic Filter – our preferred tool for logical analysis of Microsoft Project schedules – could not completely overcome the weaknesses of MSP when it came to resource leveling.
To be amenable for logical analysis, it seemed that schedules needed to be constructed with “soft” logic links to mimic the impacts of the resource leveling algorithm.

As the developer and primary user of BPC Logic Filter, I was not satisfied with these latter conclusions. After all, I had developed the tool specifically to overcome MSP’s shortcomings in the context of multiple deadlines/constraints and variable calendars. Why should it stop there?

While I have intended to address resource constraints in BPC Logic Filter since the beginning, I didn’t have much need for it until recently. Now the latest code revision incorporates full analysis and comparison of resource assignments in parallel with the existing logic analysis algorithm. I’m pleased with the results and feel confident that BPC Logic Filter can now depict the Resource Critical Path (or any resource-constrained driving path) in a Microsoft Project Schedule.

Figure 8 of the earlier article showed the resource-leveled schedule of a simple construction project, while Figure 9 showed BPC Logic Filter’s multiple-float-path analysis of the schedule. The latter figure demonstrated how resource leveling introduced gaps into the logical arrangement of the schedule, but it did not track the resource constraints behind those gaps. Figure 11 of the earlier article demonstrated the analysis after replacing the resource-leveling delays with soft (“preferential”) logic links to create exactly the same (early) schedule dates. I’ve included these figures below.

Figure 9: Logic Analysis of Leveled Schedule

Figure 11: Logic Analysis of Schedule with Preferential Logic Instead of Leveling

Now I’ve added a figure (let’s call it Figure 12) showing the “new and improved” analysis from BPC Logic Filter. The top band of the figure illustrates the Resource Constrained Critical Path for the project as originally scheduled and leveled (i.e. without preferential logic). The dates remain unchanged. The relative float values for all tasks are identical to those of the revised (preferential-logic) schedule, but the total slack, critical flag, and bar colors are as originally scheduled and leveled. The next figure (13) shows a revised version of the bar chart with custom bar colors applied to clarify the logic- and resource-driven paths. This is comparable to MSP’s “Task Path” graphical display (though of course that tool is limited to logical paths, does not differentiate among relative float paths, and has no filter.)

Resource Constrained Critical Path from BPC Logic Filter — Figure 12: New Logic Analysis of Leveled Schedule – i.e. Resource Constrained Critical Path

Figure 13 – BPC Logic Filter Bar Colors

To summarize, BPC Logic Filter now includes full analysis of driving resource constraints for leveled schedules.

I’ve tested the upgraded functionality against some of the more sophisticated leveling scenarios, like split-assignments, split-tasks, and in-progress tasks with splits. I’ve also stress-tested the algorithms against some public-domain resource-constrained schedule datasets – namely PSPLIB files j1201_7 and j12060_10, both leveled by MSP with default parameters. For the latter project, BPC Logic Filter required nearly two minutes to chug through the numerous parallel resource-driving paths. (The project includes large pools of homogeneous resources distributed among many small tasks, which I hope is not typical.)

For now, the resource-analysis features do not work across multiple projects (i.e. linked master/sub-project structures.)

Finally, the banner/featured image at the top of this article is an updated version of the project schedule, with a couple arrows added to depict the inherent logic of the resource leveling delays. It would be great for the program to insert these arrows automatically, but I’m afraid the necessary effort isn’t justified at this time. Maybe I’ll revisit in the future.

[See a related video entry here: Video-Using BPC Logic Filter to Analyze Resource Leveled Critical Path]

Resource Leveling Breaks the “Critical Path” – Logic Analysis of Resource-Leveled Schedules (MS Project)

[31Mar’16: The latest release of BPC Logic Filter now includes resource leveling constraints in the logical path analysis. I’ve written another article to summarize and amend this one: The Resource Critical Path – Logic Analysis of Resource-Leveled Schedules (MS Project), Part 2 .]

Effective management of resources – i.e. planning, procuring, mobilizing, and deploying – is a core competency for successful companies in project-focused industries like construction. Most scheduling tools based on the Critical Path Method (CPM) – like Microsoft Project – can generate project schedules without resources, but they also include methods for assigning, analyzing, and “leveling” project resources. In this context, “leveling” means selectively delaying some work (compared to the CPM-based schedule) pending the completion of other, more urgent works that demand the same resources.

This simple description might imply that a certain logical/sequential relationship is imposed between two competing tasks (i.e. the “less urgent” work can only start after the “more urgent” work is finished with the resources) – sometimes called “soft logic”. Unfortunately, the leveling engine in Project 2010 does not appear to use, much less preserve, any such soft logic. Consequently, logical analysis of the leveled schedule – including interpretation of Total Slack to determine critical path or driving logical path – appears invalid.

Figure 1: Simple Construction Project with Resource Loading

Figure 1 is a simplified CPM model of a construction project involving multiple trades working in multiple areas. The model includes realistic resource loading, but the logical links have been limited to “hard logic” only (i.e. physical constraints). In other words, there is no preferential logic to guide the resource deployments. The default 5dx8h weekly calendar is universally applied, and a deadline of 25Feb’04 has been imposed. The unleveled CPM schedule includes a forecast completion that is nearly 3 months ahead of the deadline, but resources are severely over-allocated – the schedule appears unrealistic and needs to be leveled.

Specifically:

Three civil works tasks are running concurrently, but there is only sufficient manpower to run them sequentially. (Figure 2.)
Three structural tasks are also running concurrently, and these require both manpower (Figure 3) and a crane (Figure 4), which is the limiting resource. They must be done sequentially.
There is room to install the five separate processing lines concurrently in Area 3, but there is only enough skilled manpower to install them one at a time. (Figure 5).
An electrical change order has been approved in Area 2, but this requires the same specialized crew that is already working there. The Change-order work must be delayed (Figure 6).

Figure 2: Over-Allocation of Civil Works Manpower

Figure 3: Over-Allocation of Structural Erection Manpower

Figure 4: Over-Allocation of Crane for Structural Erection

Figure 5: Over-Allocation of Mechanical Installation Manpower — Figure 5: Over-Allocation of Area 3 Specialized Mechanical Installation Manpower

Figure 6: Over-Allocation of Specialized Electrical Manpower — Figure 6: Over-Allocation of Area 2 Specialized Electrical Manpower

It is a simple matter to remove the over-allocations by manually executing Project’s leveling engine using near-default conditions (Figure 7).

The leveling engine resolves the over-allocations by selectively delaying those tasks (and task resource assignments, if specified) which are judged to be lower-priority according to Project’s proprietary rules. Figure 8 illustrates the results of the leveling exercise:

The primary artifact of the leveling process is the “leveling delay” task property, which is in units of elapsed-duration (i.e. “edays”). The leveling delay is incorporated into the forward-pass schedule calculation, pushing the early start dates of the affected tasks. (Separate leveling delays can also be applied to resource assignments, which can extend task durations. This has not been done here and is generally not recommended when assigned resources are expected to work concurrently – e.g. Crane and structural erection crew.) Leveling delay is also incorporated into the backward pass, removing “phantom slack” from logically-connected tasks.
Through the task leveling delay, the civil, structural, mechanical, and electrical tasks have been re-scheduled sequentially.
Substantial Completion has been delayed until two weeks after the deadline, resulting in 10 days of negative slack on the milestone and its logical driving predecessors.
There is not an obvious (-10d) total-slack path from beginning to end of the project.

Figure 9 illustrates the use of BPC Logic Filter to determine the driving path logic of the Substantial Completion task after leveling. The driving path is comprised of four tasks and two milestones separated by gaps, and the intervals of the gaps are determined by the “leveling delay.” Unfortunately, this does not describe a “resource constrained critical path.” In fact, the obviously critical tasks without leveling delay – including the first (i.e. “A1”) Civil and Structural works and the A2 Electrical works – now have high values of total slack and are shown far from the critical path. Consequently, it is clear that logical path analysis – including any evaluation of Total Slack – is not consistent with the rule-based resource leveling algorithm used by Microsoft Project.

Figure 10 illustrates the un-leveled schedule, revised to include obvious preferential logic for avoiding resource conflicts. The resulting task sequences and schedule dates are identical to those of the leveled schedule seen earlier, but the associated total slack values and “critical” flags are substantially different. As shown in Figure 11, however, the logic paths are clear and consistent with the real resource constraints of the project. The “BPC Relative Float (d): 0” group appears to represent the true resource constrained critical path for the project.

Figure 10: Preferential (Soft) Logic in Unleveled Schedule

Figure 11: Logic Analysis of Unleveled Schedule with Preferential Logic

To recap, Microsoft Project’s proprietary resource leveling engine offers a convenient tool for resolving resource conflicts in project schedules, and this functionality seems heavily used and highly valued in some industries. It does not appear appropriate, however, for use in complex projects where formal logical sequencing of tasks – including identification of Critical Path or Critical Chain – is required. In particular, Project’s “Critical” flag will fail to accurately mark the critical path in a resource-leveled schedule. Consequently, a project specification that requires both a logic-driven schedule basis and heuristic resource leveling appears contradictory.

[Click here to proceed to the follow-up article: The Resource-Constrained Critical Path – Logic Analysis of Resource-Leveled Schedules (MS Project), Part 2 .]