What is the Longest Path in a Project Schedule?

In Project schedules, the Longest Path yields the Shortest Time.  Aside from the cognitive gymnastics needed to digest that phrase, the concept of Longest Path – especially as implemented in current software – has deviated enough from its origins that a different term may be needed.   

Critical Path as Longest Path

Authoritative definitions of the “Critical Path” in project schedules typically employ the words “longest path,” “longest chain,” or “longest sequence” of activities … (that determine the earliest completion date of the project.)  In other words, the path, chain, or sequence with the greatest measured length is the Critical Path.  As a rule, however, none of the associated documents are able to clearly define what constitutes the length of a logic path, nor how such length will be measured and compared in a modern project schedule.  Without a clear standard for measuring the length of something, explicitly defining the Critical Path in terms of the longest anything is just sloppy in my view.

The Original Path Length

Assessing path length used to be much easier.  In the early days of CPM (Critical Path Method) scheduling, any project schedule could be guaranteed to have ALL Finish-to-Start relationships, NO constraints, NO lags or leads, NO calendars, and only ONE Critical Path.  Under these conditions, the length of a logic path could be clearly defined (and measured) as the sum of the durations of its member activities.  Thus, the overall duration of a Project was equal to the “length” (i.e. duration) of its Critical Path, which itself was made up of the durations of its constituent activities.  That result is indicated in the figure below, where the 64-day project length is determined by the durations of the 5 (highlighted) activities on the Critical Path.  Adding up the activity durations along any other path in the schedule results in a corresponding path length that is less than 64-days – i.e. not the “longest” path. [The network diagram was taken from John W. Fondahl’s 1961 paper, “A Non-Computer Approach to the Critical Path Method for the Construction Industry,” which introduced what we now call the Precedence Diagramming Method.  Unfortunately, Microsoft Project (MSP) has an early limit on dates, so his presumed ~1961 dates could not be matched.]

Fortunately, in such simple projects, it’s never been necessary to aggregate and compare the lengths of every logic path to select the “longest path.”  The CPM backward pass calculations already identify that path by the activities with zero-Total Float/Slack, and successively “shorter” paths are identified by successively higher Total Float/Slack values.  This fact has been verified in countless student exercises involving simple project schedule networks, typically concluding with the axiom that “the Critical Path equals the longest path, which equals the path of zero-Total Float/Slack.”

Float/Slack and Path-Length Difficulties

In general, modern complex project schedules have, or can be expected to have, complicating factors that make Total Float/Slack unreliable as an indicator of the Critical Path – e.g. non-Finish-to-Start relationships, various early and late constraints, multiple calendars, and even resource leveling.  See this other article for details.  Therefore, as noted earlier, the axiomatic definition has been shortened to “the Critical Path equals the longest path.”

Unfortunately, finding the “longest path” by arithmetically summing the activity lengths (i.e. durations) along all possible logic paths and comparing the results – not easy to begin with – has gotten more difficult.  Lags, unusual calendar non-working time, early constraints, and resource leveling delays all add to the true “length” of a logic path compared to the simple summation of activity durations.  On the other hand, leads (negative lags), excess calendar working-time, and the use of overlapping-activity relationships (e.g. SS/FF) reduce its length.  In addition, any hammocks, level-of-effort, and summary activities need to be excluded.  All such factors must be accounted for if the “longest path” is to be established by the implied method of measuring and comparing path lengths in the project schedule.  I don’t know of any mainstream project scheduling software that performs that kind of calculation.  Alternatively, Deep Schedule AnalysisTM using the proprietary HCP (Hidden Critical Path) Method – from HCP Project Management Consulting – appears to compute and compare the lengths of all logic paths in Primavera and MSP schedules.

Longest Path as Driving Path

Contrary to summing up and comparing logic path lengths, current notions of the “longest path” are based on an approach that does not involve path “length” at all.  As a key attribute, the longest path in a simple, un-progressed project schedule also happens to be the driving logic path from the start of the first project activity to the finish of the last project activity.  It is a “driving logic path” because each relationship in the path is “driving”, that is it prevents its successor from being scheduled any earlier than it is.  Driving relationships are typically identified during the forward-pass CPM calculations.  Subsequently, the driving path to the finish of the last activity can be identified by tracing driving logic backward from that activity, terminating the trace when no driving predecessors are found or the Data Date is reached.  The resulting driving path to project finish is also called the “longest path” even though its “length” has not been established.  This is the “Longest Path” technique that has been applied for nearly two decades by Primavara and adopted more recently in other project scheduling tools.

As of today, MSP continues to define Critical tasks on the basis of Total Slack, but it provides no explicit method for identifying the “Critical Path” using a “longest path” criterion.  How is the responsible MSP scheduler supposed to respond to a demand for the “critical path” when the longest path has been obscured?  Here are several options:

  1. Continue to make simple projects, avoiding all complicating factors like calendars (including resource calendars), early and late constraints, deadlines, and resource leveling. Then assume that “Total Slack = 0” correctly identifies the Critical Path.
  2. If you are using MSP version 2013 or later,
    1. Ensure that your project is properly scheduled with logic open-ends only present at a single start and single finish task/milestone, then select the single finish task,
    2. Try to use the “Task Path” bar highlighter to highlight the “Driving Predecessors” of your selected finish task.  In the example below, a Deadline (a non-mandatory late-finish constraint) has been applied to task Op12 in the 1961 example, and MSP has responded by applying the “Critical” flag (based on TS=0) to Op12 and its predecessors Op10 and Op2.  As a result, the Critical Path is obscured.  Applying the bar highlighter and selecting task Op18 (the project’s finish task) correctly identifies the driving path to project completion, i.e. the “longest path.”  (For clarity, I manually added the corresponding cell highlighting in the table; the bar highlighter doesn’t do that.)
    3. If necessary, create and apply a corresponding filter for the highlighted bars. I’ve posted a set of macros to make and apply the filter automatically in this article.
  3. If you are using MSP version 2007 or later,
    1. Ensure that your project is properly scheduled with logic open-ends only present at a single start and single finish task/milestone, then select the single finish task,
    2. Try to use the Task Inspector to identify the driving predecessor of the selected task, then go to it and flag it as being part of the driving path. Repeat this until the entire driving path is marked.
    3. If necessary, create and apply a filter and/or highlighting bar styles for the flagged tasks.
    4. I’ve posted another set of macros to do all this (except bar highlighting) automatically in this other article.
  4. Note: The previous two approaches both rely on MSP’s StartDriver task object to identify driving relationships. As noted in this article, however, the resulting driving logic is not reliable in the presence of tasks with multiple predecessors, non-FS predecessors, or actual progress.
  5. Use BPC Logic Filter or some other appropriate add-in to identify the “longest path” in the schedule.

Whichever method or software is used, expressing the Longest Path using the Driving Path methodology has one key weakness: it has not been proved generally useful for analysis of near-critical paths.  While the Longest Path may be known, its actual length is not readily apparent.  More importantly, there is no basis for computing the lengths, and hence the relative criticality, of the 2nd, 3rd, and 4th etc. Longest Paths.  Consequently, Near-Critical paths continue to be identified based on Total Float/Slack, which is still unreliable, or – in P6 – based on unit-less “Float Paths” from multiple float path analysis.

BPC Logic Filter – Longest Path Filter

BPC Logic Filter is a schedule analysis add-in for MSP that my company developed for internal use (though we still share it as of this writing.)  The Longest Path Filter module is a pre-configured version of the software’s Task Logic Tracer.  The module is specifically configured to identify the project’s longest path (as driving path) through the following actions:

  1. Automatically find the last task (or tasks) in the project schedule.
    1. Excluding tasks or milestones that have no logical predecessors. (E.g. completion milestones that are constrained to be scheduled at the end of the project but are not logically tied to the actual execution of the project. The resulting trace would be trivial.)
    2. Excluding tasks or milestones that are specifically coded to be ignored, e.g. (“hammocks”)
  2. Trace the driving logic backwards from the last task to the beginning of the project.
    1. Driving logic is robustly identified by direct computation and examination of relative floats. (Driving relationships have zero relative float according to the successor calendar.)  The unreliable StartDriver task objects are ignored.
    2. Neither completed nor in-progress tasks are excluded from the trace.
  3. Either apply a filter to show only the driving logic path, or color the bars to view the driving logic path together (in-line) with the non-driving tasks. The example below is identical to the previous one, but BPC Logic Filter formats the bar chart to ignore the impacts of the applied deadline.  The resulting in-line view is substantially identical to the bar chart of the original, unconstrained project schedule. 

“Longest Path” and Early Constraints

As noted several times here, the methods described for identifying the “longest path” are in fact describing the “driving path to the project finish.”  This distinction can raise confusion when an activity is delayed by an early constraint.  Consider the case below, where an activity on the longest path (Op13) has been delayed 2 days by an early start constraint.  Consequently, its sole predecessor relationship (from Op3) is no longer driving, and Op3 gains 2 days of Total Float/Slack.  As shown by MSP’s “Driving Predecessor” bar highlighter, the driving logic trace is terminated (going backwards) after reaching the constrained task.

Identical results are obtained from Primavera’s (P6) Longest Path algorithm.  This is neither surprising nor incorrect; the project’s completion is in fact driven by the external constraint on Op13, and its predecessor Op3 is quite properly excluded.

It’s clear therefore that the driving path to project completion and the longest path from the project start (or Data Date) to the project completion can differ when an early constraint is present.  P6’s “Longest Path” algorithm automatically defaults to the driving path, not the actual longest path, and to date there have been no built-in alternatives to that behavior.  As a result, some consultants suggest that P6 Longest Path analyses should be rejected when external constraints – even legitimate ones like arrival dates for Customer Furnished Equipment – are present.  (A P6 add-in, Schedule Analyzer Software, does claim to provide a true Longest Path representation in the presence of early constraints.)

BPC Logic Filter and the (True) Longest Path

It is debatable, in my view, whether the addition of non-driving, float-possessing activities into the “longest path” makes that term itself more or less useful with respect to the typical uses of the “Critical Path” in managing and controlling project performance.  Nevertheless, such an addition is easily allowed in BPC Logic Filter by checking a box.  The bar chart below shows the results of the Longest Path Filter on the early-constrained example schedule, as set up according to the driving-path (Primavera) standard.  Results are identical to those of the built-in “Driving Predecessors” highlighter in MSP (above) and of P6.

The next chart shows the complete “longest path” for the project, including the non-driving Op3 activity.

The second chart is different because the check box for “Override if successor task is delayed by constraint” has been checked in the analysis parameters form.  Checking the box causes the non-driving predecessor with the least relative float to be treated as driving, and therefore included in the Longest Path, in the event of a constraint-caused delay.

For a quick illustration, see Video – Find the Longest Path in Microsoft Project Using BPC Logic Filter.

BPC Logic Filter and Near Longest Paths

As noted earlier, the normal methods for identifying the “longest path” (i.e. the driving path) in a project schedule have not been generally adopted for analyzing near-longest paths.  P6 offers multiple float path analysis, which I wrote about here.  In addition,  Schedule Analyzer (the P6 add-in mentioned earlier) computes what it calls the “Longest Path Value” for each activity in the schedule – this is the number of days an activity is away from being on the Longest Path (i.e. the driving path to project completion.)   In the absence of demonstrated user demand, however, MSP seems unlikely to gain much beyond the Task Path bar highlighters.

BPC Logic Filter routinely computes and aggregates relative float to identify driving and near-driving logic paths in MSP project schedules.  In this context, “near-driving” is quantified in terms of path relative float, i.e. days away from driving a particular end task (or days away from being driven by a particular start task.)  Its “Longest Path” and “Near Longest Path” analyses are special cases where the automatically-selected end task is the last task in the project.  For the Near Longest Path Filter, tasks can be shown in-line (with bar coloring) or grouped and sorted based on path relative float.  The “override if successor is delayed by constraint” setting has no effect when the Near Longest Path Filter is generated.  In that case, the non-driving task will be displayed according to its actual relative float.  For example Op3 is shown below with a relative float of 2 days (its true value), not 0 days as shown on the earlier Longest Path Filter view.

Longest Paths in Backward Scheduled Projects (MSP) [Jan’19 Edit]

As pointed out in this recent article, the Longest Path in a backward scheduled project is essentially the “driven path from the project start,” not the “driving path to project completion.”

For more information, see the following links:

Article – Tracing Near Longest Paths with BPC Logic Filter

Video – Analyze the Near-Longest Paths in Microsoft Project using BPC Logic Filter

Avoid Out-of-Sequence Progress in Microsoft Project 2010-2016

Recording Actual dates that violate existing schedule logic can cause conflicts in Microsoft Project’s internal schedule calculations. The resulting Total Slack values and Critical task flags can be incorrect and misleading.  These issues are aggravated by recent (e.g. MSP 2016) versions of the software, and users are advised to minimize out-of-sequence progress.

Recording of actual progress in a logic-driven project schedule can be problematic.  As the “Actual” dates override or otherwise constrain the computed dates, the customary definitions of Float or Slack – and their resulting impacts on the “Critical” task flag in Microsoft Project (MSP) – no longer apply.  While I hope to undertake a general review of progress updating issues in a future article, this one has a special focus on out-of-sequence progress for two primary reasons:

  1. In all modern versions of Microsoft Project (e.g. ~MSP 2007+), the Total Slack values of “Critical” tasks with out-of-sequence successors can be altered unexpectedly.
  2. In MSP 2016 (and possibly beginning with MSP 2013), the Total Slack values of ALL tasks (not just “Critical” tasks) with out-of-sequence progress among their successors can be altered unexpectedly. As a result, many tasks can be shown incorrectly as “Critical” in MSP 2016 when they are not “Critical” in earlier versions.

What is Out-of-Sequence Progress

Out-of-sequence progress exists when actual progress is recorded (via, e.g. Actual Start, Actual Duration, Actual Work, %Complete, etc.) at times when the logical constraints of the schedule would normally preclude it.  For example:

  • An Actual Start is recorded for a task (the out-of-sequence, or OOS, task) whose Finish-to-Start predecessor has not finished. I.e. the Actual Start precedes the Early Start;
  • An Actual Start is recorded for an OOS task whose Start-to-Start predecessor has not started. Again, the Actual Start precedes the Early Start;
  • An Actual Finish is recorded for an OOS task whose Finish-to-Finish predecessor has not finished. Here the Actual Finish precedes the Early Finish.

In all cases there is a presumption that the recorded actual progress is more correct than the (theoretical) schedule model, so Early and Late dates are routinely overwritten by Actual dates during the schedule calculations.  When the actual progress occurs out of sequence, however, computing the Late dates (and slack values) of incomplete predecessors (during the “Backward Pass” calculations) is complicated by logical conflicts.  The software typically resolves these conflicts in a way that satisfies the needs of most users.

Completed, Out-of-Sequence Tasks

The issues discussed here are of primary concern in those cases where a task has started out of sequence and a) it remains incomplete; and b) the violated predecessor relationships remain unsatisfied (e.g. the FS predecessor remains incomplete.)  If either the OOS task or its unfinished predecessor task become complete, then they are treated like other completed tasks in Microsoft Project.  That is, they can influence the Early dates of their successors but have no impact on the Late dates of their predecessors.  As a result of this latter condition, an incomplete task whose sole successor has been completed out of sequence becomes effectively open-ended, i.e. without successors.  Under default conditions (i.e. “calculate multiple critical paths” NOT checked), the task’s Late Finish is set equal to the project’s Early Finish Date, and a high value of Total Slack is computed.

Obviously, this can have a major impact on the apparent Critical Path of a project.  In the example below, tasks CP2 and SP2 have both been completed out-of-sequence, and at a duration of only 20% of their baseline durations.  The overall project has been shortened, but the Critical Path has been truncated at CP3.  CP1 is no longer “Critical” because, in effect, it no longer has any successors.  It appears necessary to add a new FS relationship from CP1 to CP3 (and equivalently between SP1 and SP3) to re-establish the logic chain that has been broken by the completed, out-of-sequence tasks.

In-Progress, Out-of-Sequence Tasks

Key issues arise when the out-of-sequence task and its predecessor are both incomplete.  Because this behavior is sometimes different for MSP 2016 than it is for MSP 2010, we’ll look at both versions for the remaining examples.

For exploring the behavior of in-progress, out-of-sequence tasks, we examine the simple project schedule below.  The schedule is comprised of a single start milestone, a single finish milestone, a “Critical Path” string of four tasks, and a “Slack Path” string of four tasks.  The “Slack Path” is two days shorter than the “Critical Path,” with the last two tasks each having a shorter duration.  There is an unachievable Deadline applied to the finish milestone, and this creates negative Total Slack on the Critical Path.  Thus, the Critical Path tasks all have TS=-1d, and the Slack Path tasks have TS=1d.

With no progress, the project is scheduled identically in both versions of the software.

Now let’s examine what happens when we record an out-of-sequence Actual Start on some future task.  In the example, the last task in each string (CP4 and SP4) is given an Actual Start that is one day earlier than its predecessors allow.  To keep things simple, no progress beyond the actual starts are recorded (i.e. %Complete = 0%.)  I’ve kept the “Split in-progress tasks” scheduling option checked (per default), so re-scheduling the project creates an initial split in tasks CP4 and SP4 and delays their remaining parts to satisfy the predecessor relationships.  As a result, all the tasks keep the same finish dates as before, and the project finishes on the same date as before, one day after the Deadline.

Although their start and finish dates have not changed, the logic-related information of the predecessors of the OOS tasks have been altered substantially.

  1. In both MSP 2010 and MSP 2016:
  • The Total Slack values of the Critical Path tasks that precede the OOS task (i.e. tasks CP1, CP2, and CP3) are all changed from TS=-1d to TS=0d.
  • This behavior is not justified: if the tasks are all executed according to the scheduled dates, the project will still finish one day late. The tasks should still have TS=-1d.
  • This is in fact a general result (see also Comment 1): (Presumably for MSP 2007 through MSP 365), any super-critical (TS < 0) task with an out-of-sequence, in-progress task in its successor chain will automatically have its Total Slack re-set to zero. Thus, out-of-sequence progress can cause a task with 60 days of negative Total Slack to appear much less Critical than it is.
  • This behavior can present a problem for project managers operating in a negative-slack (i.e. behind-schedule) regime, where schedule-recovery efforts are prioritized based on Total Slack values. Entering a single OOS Actual Start value (whether correct or not), can substantially alter the overall schedule recovery picture.
  • It seems most MSP users pay no attention to Total Slack values beyond the application of the “Critical” flag, and the observed behavior doesn’t change that. Consequently, for most users up through MSP 2010, out-of-sequence progress appears to have no substantial impact on the “Critical Path.”
  1. In MSP 2016, in addition to the prior behavior:
    • In the example, the Total Slack values of the Slack Path tasks that precede the OOS task (i.e. tasks SP1, SP2, and SP3) are all changed from TS=1d to TS=0d.
    • This behavior is also not justified. The tasks could all be delayed one day from their scheduled dates without compromising the project’s completion Deadline.  The tasks should still have TS=1d.
    • This is also a general result (see also Comment 1): (presumably for MSP 365 and maybe MSP 2013), ANY task (Critical or non-Critical) with an out-of-sequence, in-progress task in its successor chain will automatically have its Total Slack re-set to zero. Consequently, it will automatically and unavoidably be flagged as a Critical task.
    • For general MSP users after MSP 2010, therefore, out-of-sequence progress can have a substantial, even major, impact. In particular, tasks that are actually far from the Critical Path may be incorrectly flagged as Critical.

Below I’ve shown another perhaps more realistic example of the same simple project.  There has been a simple progress update on the Status Date of 1Oct’18, four working days into the project.  As of that date (the first Monday in the project), tasks CP1 and SP1 are still in-progress and have fallen one day behind the original plan.  Their successors (CP2 and SP2) have been allowed to start early, however, with each recording one day of actual progress.

Similar logical results are observed.  Task CP1 – the Critical predecessor of the Critical OOS task CP2 – now has TS=0d instead of TS=-1d in both software versions, and its Critical flag remains unchanged.

In MSP 2016 only, task SP1 – the non-critical predecessor of the non-critical OOS task SP2 – now also has TS=0d and is flagged as Critical.  This is incorrect.

Out-of-Sequence Progress and Task Path Driving Predecessors in MSP 2016

The “Task Path” bar styles provide useful methods for identifying related tasks, including the Driving Predecessors path, for any selected task in MSP 2013+.  The Driving Predecessors Task Path is particularly useful for confirming the Critical Path of a project when Total Slack is complicated by other factors.  Unfortunately, the method is not successful when out-of-sequence progress is encountered.  As shown in the figure below – repeating the two previous examples in MSP 2016 – the Driving Predecessors Task Path (orange-colored bars) is terminated when an Actual Start is reached on the backward (right-to-left) pass.  Thus, driving Task Path functionality is not compatible with out-of-sequence progress.

[The Task Path functionality is equally incompatible with in-progress schedules that involve Finish-to-Finish relationships among overlapping tasks, even if none of the progress occurs out of sequence.  Any Actual Start value terminates the progression of the associated bar formatting flag.]

Out-of-Sequence Progress and BPC Logic Filter

The impacts of out-of-sequence progress on the Total Slack of some tasks are the result of specific decisions in MSP’s backward-pass algorithms for computing Late dates and Total Slack.  Obviously, the algorithm has been tweaked between MSP 2010 and MSP 2016 leading to the even more undesired results.

BPC Logic Filter – my company’s MSP add-in for logic analysis – generally ignores MSP’s Deadlines, Late dates, Actual dates, and Total Slack values.  Instead, it performs separate backward and forward traces to determine driving logic paths and relative float values.  The latter, like Free Float, can never be negative.  Thus, when BPC Logic Filter encounters out-of-sequence progress during a trace, zero relative float is applied, and a driving relationship is inferred.  As shown in the examples below, this approach results in the correct identification of driving and near-driving paths to project completion, even when out-of-sequence progress is encountered.  [In the bar charts, the path relative float is listed to the right of each bar.  A zero-value represents the driving path with the bar characteristically colored (maroon), positive values and associated bar colors indicate the number of days away from driving the project completion.  (I had to manually fix the bar colors for the in-progress tasks in the MSP 2016 version, as there is an unfixed bug in that version that affects bar-coloring in our software.)

BPC Logic Filter also includes a Project Logic Checker to identify logic issues in Microsoft Project tasks.  Like many such tools, it automatically flags OOS tasks, along with their immediate predecessors, for correction.

 

Out-of-Sequence Progress in the Real World

This examination was prompted by an associate who, after a recent “upgrade” from MSP 2007 to MSP 2016, encountered numerous unexplained changes in the “Critical Path” during project updating.  As it turned out, the schedule that was shared with me contained extensive out-of-sequence progress that explained the observed behavior.  The extensive out-of-sequence progress was the result of a schedule model that was ultimately invalid – a poor representation of the work, either as planned or as actually executed.  As is often the case in construction, this was aggravated by the persistent executive schedule pressure that converts some technological restraints (e.g. don’t start interior finishes until the building roof and skin are closed up) from mandatory requirements into mere preferences.

A typical invalid schedule model involves the representation of multiple overlapping activities as an over-simplified Finish-to-Start string.  For example, the schedule below shows five sequentially-related, non-critical tasks, of roughly equivalent work content, that are scheduled to occur over a five-week period.  Although they are shown sequentially, it is in fact customary to execute these five tasks nearly concurrently, with each task commencing as soon as its predecessor’s progress allows – and thereafter suspending or pacing progress to match that of its predecessors.

[Some schedule purists would suggest that these tasks should be broken down into many small, repetitive work packages, all arranged with pure Finish-to-Start logic relationships.  The resulting schedule is extremely detailed and reflects a true logical plan for executing the work.  In my experience, however, such a detailed plan can often be riddled with preferential logic that is ultimately over-ruled by field decisions.  Out-of-sequence progress – in spades – is the inevitable result; the scheduling workload multiplies with no added value.

Another approach might involve five parallel tasks, each of five weeks duration, modeled with continuous relationships or at the very least with compound (joint SS + FF) relationships.  Unfortunately, neither relationship is supported by MSP.  The dummy-milestone approach that I use to mimic compound relationships in MSP seems fairly esoteric, and the common alternative – using solely SS or FF relationships – can be problematic.]

The scheduler here has chosen the most expedient route, a simplified Finish-to-Start string of five activities.  Four weekly updates of actual progress then lead to the progressed schedule shown at the bottom of the figure.  While its appearance is substantially changed compared to the original plan, the progressed schedule – in MSP 2010 – seems to correctly depict the status and slack of the multiple in-progress, out-of-sequence tasks.  Thus MSP 2010 seems largely indifferent to the consequences of invalid logic combined with out-of-sequence progress, as long as the affected tasks are non-critical.

As my associate discovered, however, MSP 2016 is far less tolerant of such practices.  When the progressed schedule is recalculated in MSP 2016, the in-progress predecessors of the in-progress, out-of-sequence tasks are shown as Critical (with TS=0).  This is incorrect, as the tasks could all slip by 15 days without delaying the project.

Review and Recommendations

Out-of-sequence progress is an unwelcome but often unavoidable occurrence in projects with logic-driven schedules.  It happens when the actual project execution is allowed to deviate from the plan in a way that creates logical conflict in the automatic scheduling calculations.  It typically results from a combination of the following circumstances:

  1. The schedule plan includes logic relationships that are not technologically mandatory. I.e. there are a number of alternative methods available for sequencing a group of related activities, and only one (preferred) method is incorporated into the schedule.  In addition:
    • Procedural controls are inadequate to ensure that project execution conforms to the preferred logic sequence; or
    • Subsequent to initial schedule development, the preferred logic sequence is altered due to field conditions, resource limitations, or other latent factors.
  2. Subsequent to initial schedule development, technologically-mandatory logical constraints are allowed to be violated – typically under schedule performance pressure – and the resulting technical risks are accepted.
  3. The schedule is based on scope and logic definitions that are overly simplified compared to the actual or achievable plan of execution. E.g. simple Finish-to-Start relationships are used to represent overlapping, partly-concurrent activities.
  4. Subsequent to occurrence of any of the prior circumstances, the schedule logic is not revised appropriately.
  5. Schedule updates do not include regular review and correction of invalid logic in light of out-of-sequence progress.

In MSP, a task that is both started and completed out-of-sequence may cause the incomplete tasks in its predecessor and/or successor chains to become effectively open-ended, with consequent impacts on Early and Late dates, Total Slack, and Critical task definition.  Consequently, the updated schedule may be invalid.

A task that is started out-of-sequence but remains in progress may cause substantial alterations to the Late dates, Total Slack, and Critical definitions of the incomplete tasks in its predecessor chains.  In particular:

  1. (In all modern MSP versions) Total Slack of behind-schedule tasks will change from negative to zero and in some cases turn positive. [See also comment 1.] Although the Critical flag won’t always change, any identification of driving and driven logic paths that is based on negative Total Slack will be incorrect.
  2. (In recent versions – e.g. MSP 2016) Total Slack of non-Critical tasks will change from positive to zero (with some exceptions), and each task will be incorrectly marked as Critical. [See also comment 1.]  Thus, the “Critical Path” and any other Slack-based identification of driving or driven logic paths will be incorrect.

These are pretty major consequences, yet their persistence suggests that they reflect as-designed behavior, not bugs.  It might even be suggested that the most recent “improvements” are intended to highlight the out-of-sequence progress – for correction of the associated logic.

In MSP, the only reliable way to avoid the negative consequences of out-of-sequence progress, in my opinion, is to avoid and/or minimize its occurrence.  Fundamentally, this means:

  1. Ensure that project schedules are based on sound consideration of the scope and logic of project execution.
  2. Ensure that procedural controls are put into place to a) validate, b) revise where necessary, and c) enforce the preferred sequence of activities.
  3. Where necessary, revise the schedule logic to reflect the actual/required sequence of execution.
  4. During regular progress updates, identify all out of sequence progress, and revise associated logic as appropriate to avoid the consequences noted above.