Driving Logic in Backward Scheduled Projects (Microsoft Project)

Microsoft Project’s backward scheduling mode includes numerous traps for novices and professionals alike.  Competent project schedulers avoid it.

In MSP, a backward scheduling mode – sometimes called backward planning, reverse scheduling, or reverse planning – can be invoked by scheduling the project from its finish rather than its start.  In the traditional language of critical path method (CPM) scheduling, it’s most simply described as a late-dates schedule.  Backward planning is useful in several non-standard methodologies, including critical chain project management and the pull planning aspects of the Last Planner System.

The Mechanics of Backward Scheduling

When specified for the active project, this mode essentially does the following:

  1. Sets the default constraint type for all new tasks to as late as possible (ALAP).
  2. Re-sets the constraint type to ALAP for all existing Summary tasks.
  3. [Users choosing this mode in the middle of schedule development must manually re-set the constraint type to ALAP for all existing non-Summary tasks.]
  4. Automatically sets no later than constraints when dates are manually entered into the start or finish fields of tasks.  [Such date entry in forward scheduling mode leads to “no earlier than” constraints, so users choosing this mode in the middle of schedule development should manually review, validate, and potentially re-set any previously-entered date constraints.]
  5. Performs the network scheduling calculations in reverse order, with the reflection point occurring at the project start rather than the project finish.  I.e. the project start date (not the finish, which is user-input) is determined by the logic.
  6. Sets the start and finish of automatically-scheduled tasks to their late dates rather than their early dates.  (This is the most important part.)
  7. Finally, the resource leveling engine resolves resource over-allocations by accelerating higher priority tasks from late dates rather than delaying lower priority tasks from early dates.  Thus, entries in the leveling delay field are negative.  This behavior creates a minor complication regarding use of priority = 1000.  Just as in forward scheduling, a task with priority=1000 is always exempted from any leveling action.  In backward scheduling, this means that priority values of 1000 and 0 are essentially equivalent when considered in the leveling decisions.  The highest effective priority for controlling leveling behavior then becomes 999, not 1000.

Logic relationships used in backward scheduling still have exactly the same meanings that they do in forward scheduling.  A finish-to-start (FS) relationship still means that the two tasks are logically connected such that the successor may not start before the predecessor finishes, and the rarely-applicable start-to-finish (SF) relationship still indicates that it is impossible for the successor to finish before the predecessor starts.  Some users seem to think that backward scheduling involves reversal of these two relationships in particular, but that’s not consistent with the rest of the backward scheduling mode.  Unfortunately, mixing of the two approaches seems to continue, though this typically amounts to invalid date manipulation in my view.

In normal (i.e. forward) scheduling, a task with an ALAP constraint has the dubious distinction of corrupting its entire chain of successors – driving all of them to the critical path.  There are very few legitimate applications for this constraint.  In backward scheduling, the as soon as possible (ASAP) constraint plays a similar role, corrupting its chain of predecessors.  It needs to be avoided in backward scheduling.

When to Use Backward Scheduling

I’ve never used backward scheduling in a real project.  Others have recommended its use to determine the desired start date of a project when the desired completion date is already known.  It also seems consistent, when tasks are suitably buffered, with aspects of critical chain project management that require work to be scheduled as late as possible.

Ultimately, backward scheduling rests on the presumption that tasks can be accelerated (i.e. moved to the left on the bar chart) indefinitely as needed to meet the fixed end date for the project.  Thus, a task whose duration is extended can simply be re-scheduled to start sooner than previously planned, with its predecessors also being accelerated.  Similarly, a higher priority task can be started (and finished) earlier to avoid resource conflicts with a lower-priority task that demands the same resources.  The problem with these presumptions is that time invariably marches forward, and as scheduled dates for incomplete work are overtaken by the vertical time-now line on the bar chart there is no chance for recovery.  The backward scheduling method is pointless if the latest allowable project start date has already been passed – e.g. the project is in progress.

Backward scheduling seems to be of primary value in determining the latest responsible date to start a project (or project segment) while still meeting the desired completion date.  After that latest responsible start date is determined, the project must be converted from backward-scheduled to forward-scheduled mode – manually reviewing and revising the key parameters of each task – if it is to be used for updating and forecasting during project execution.  The original question – i.e. what is the latest responsible project start date? – is just as easily answered by manipulating and examining the late dates of the forward scheduled project.  Thus, for a competent project scheduler, the use of backward scheduling seems largely to be an unproductive diversion.

Driving Logic Analysis

When the logic network is well constructed – and complicating factors like multiple calendars, (early) constraints, and resource leveling are avoided – then the critical path may be reasonably identified by total slack = 0.  Other methods of driving logic analysis must be modified, however.

Under backward scheduling, any slack/float of a task exists on the side towards its predecessors, i.e. to its left on a bar chart.  A driving relationship exists when a successor prevents a predecessor from being scheduled any later than it is.  This means that there are driving successors and driven predecessors.  Consequently, the Longest Path in a backward scheduled project is the driving (successor) path from the project’s start.

MSP includes two built-in methods for reviewing and analyzing driving logic: the Task Inspector pane and the task paths bar styles.  As I wrote in this article a few years ago, I’ve found these tools to be unreliable in complex real-world project schedules.   Under backward scheduling, they are essentially useless and/or misleading.

To start with, Task Inspector simply doesn’t work with backward scheduling.  Opening TI on a backward scheduled project yields the following message:  This project is set to Schedule from Finish.  We are unable to provide scheduling information.

Also under backward scheduling, the Driving Predecessors and Driven Successors bar styles are still derived from Early Dates, as they are in Forward Scheduling.  This makes them essentially useless for assessing the controlling logic of the displayed (late-dates) schedule.  Consider the example below, where all four Task Path bar styles have been imposed, and Task 11 – A2 Structures – is selected.  (The automatic “Slack” bar style is also imposed, but it is invisible since Free Slack – formally defined by Early dates alone – is uniformly zero.)

The selected task is in fact driving/controlling the displayed dates of both of its predecessors (LRF=0), but only one of them displays the correct bar style (the one that, with ERF=0, was the driving predecessor during the forward pass).  Of Task 11’s four successors, only the first (Task 13 – A2 Electrical) is directly driving/controlling Task 11’s schedule, with LRF=0.  The tasks for two of the remaining three successor relationships are incorrectly highlighted, while the third (Task 14) is correctly highlighted only because it is driving/controlling Task 13 – a case of redundant logic.  (All four successors were driven successors during the forward pass.)  Thus in a backward scheduled project, the Task Path bar styles for Driving and Driven dependencies are meaningful (or “correct”) ONLY along the Longest/Critical path of the project, where Early dates and Late dates coincide.  The relationships along that path are driving in both directions; i.e. they are bi-directional driving relationships.

BPC Logic Filter – my company’s Add-In for logic analysis of MSP schedules – identifies driving logic based on relationship free float, which we often call “relative float.”  In BPC Logic Filter, the Longest Path and near-longest paths of simple, backward-scheduled projects can be found using the Task Logic Tracer, starting from the project start milestone and using appropriate settings (i.e. driving relationships in successor direction).  As illustrated in the example project, this is fairly trivial since the results are 100% aligned with Total Slack.

Other driving logic paths (not on the Critical Path) are not so trivial but are easily addressed using BPC Logic Filter, provided that the impact of multiple calendars is minimal.

Precision analysis of more complex, backward-scheduled projects requires some modest modifications to the algorithms.  In particular, several variations of late-relationship-float need to be computed, and these have been added to the development roadmap for the software.

[Apr’20 Revision.  I’ve updated the two figures to incorporate the early-date relative float (ERF) and late-date relative float (LRF) columns in the logic inspector windows.  Calculation of the latter was only added to recent builds of BPC Logic Filter.  These windows also flag the forward-driving (yellow), backward-driving (rose), and bi-directional-driving (red/yellow) relationships.]

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

 

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 8: Resource-Leveled Schedule
Figure 8: Resource-Leveled Schedule
Figure 9: Logic Analysis of Leveled Schedule
Figure 9: Logic Analysis of Leveled Schedule
Figure 11: Logic Analysis of Schedule with Preferential Logic Instead of Leveling
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

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: 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:

  1. Three civil works tasks are running concurrently, but there is only sufficient manpower to run them sequentially. (Figure 2.)
  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.
  3. 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).
  4. 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 2: Over-Allocation of Civil Works Manpower
Figure 3: Over-Allocation of Structural Erection Manpower
Figure 3: Over-Allocation of Structural Erection Manpower
Figure 4: Over-Allocation of Crane
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).

Figure 7: Resource Leveling Options
Figure 7: Resource Leveling Options

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:

Figure 8: Resource-Leveled Schedule
Figure 8: Resource-Leveled Schedule
  1. 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.
  2. Through the task leveling delay, the civil, structural, mechanical, and electrical tasks have been re-scheduled sequentially.
  3. 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.
  4. 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 9: Logic Analysis of Leveled Schedule

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 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 .]