← Back to list
Project & Org Management
#일정관리#주공정#Crashing#Fast Tracking#비용-일정 상충
Last updated · 2026-11-19

Schedule Compression — Crashing and Fast Tracking

1. Overview

A. Definition

Schedule compression is a schedule-management technique that deliberately shortens the duration of activities on the critical path to pull the finish date forward, without damaging the project's scope and quality goals. Its two representative levers are crashing, which adds resources and accepts higher cost, and fast tracking, which overlaps activities that were originally performed in sequence so they run in parallel; PMBOK treats both as core tools of the Schedule Management knowledge area for 'developing and controlling the schedule'.

Schedule compression matters fundamentally because a schedule slip in a project almost always spreads into a simultaneous loss of cost, trust, and market opportunity. Procurement contracts contain liquidated-damages clauses, a new product whose time-to-market is missed sees its entire revenue curve collapse, and public projects are tied to fiscal years and statutory go-live dates. Yet simply exhorting people to "go faster" only invites quality erosion and rework. Schedule compression is distinguished from gut-driven nagging in that it forces a choice made on a quantitative basis: "where (the critical path), by what method (resource injection vs. parallelization), and at what price will the duration be cut?"

B. Background and necessity

The concept of schedule compression was born in the late 1950s together with CPM (the critical-path method). Kelley and Walker of DuPont, who developed CPM, assigned each activity a normal/crash pair of duration and cost to shorten plant-maintenance duration, and formalized a time-cost trade-off model that finds the combination minimizing the extra cost (the cost slope) of shortening by one unit of time. In other words, schedule compression began from the outset as the economic optimization question "how much more does it cost to shorten the duration?"

As CPM later spread across every industry — software, construction, defense — schedule compression settled in as the natural follow-on step to network analysis. PMBOK defines it as the formal technique 'schedule compression' and presents crashing and fast tracking as its two axes. The two techniques use different levers — "spend more to inject resources" and "overlap the sequence to parallelize" — but share the common goal of cutting the critical path while preserving scope and quality.

The necessity has only grown today. First, there is the rise of fixed-deadline projects. Public next-generation systems have their go-live dates nailed down by law and public notice, finance and telecom must meet regulatory effective dates, and in manufacturing the mass-production schedule of a new model is directly tied to company-wide profit and loss. Second, there is the accumulation of requirement changes and early delays. When requirements analysis and design run late, pressure piles onto downstream processes, and keeping the finish date without cutting scope leaves schedule compression as the only option. Third, there is the speed war of the competitive environment. When a similar service launches first, the market value of a late follower plummets, so the very capability to pull the finish date forward within feasible limits while maintaining quality becomes a competitive edge. In this context schedule compression must be treated not as a mere technique but as an integrated decision that weighs risk, cost, and scope at the same time.

C. Key characteristics

The first characteristic of schedule compression is that it must target the critical path. No matter how much a non-critical activity with float is shortened, the project finish date does not change, and only unnecessary cost is incurred. Therefore every compression decision begins after first confirming "what is the current critical path." Second, compression shifts the critical path (path shifting). Shorten one path enough and another path rises as the new critical path, so compression is not a one-off calculation but a process repeated with the critical path re-identified at every step. Third, every compression has a price. Crashing pays in cost, fast tracking in risk (rework and quality defects). The only way to shorten the schedule for free is to cut scope — which, strictly speaking, is not compression but a scope change.

Fourth, schedule compression holds only on the premise that scope and quality are fixed as constants. In project management's triple constraint (scope, schedule, cost), or in the multiple constraints that include quality, pulling the one vertex of schedule necessarily moves another vertex. If scope and quality are to be left untouched, then cost (crashing) or risk (fast tracking) has no choice but to absorb that pressure. Forget this premise and try to pull the schedule in "without raising cost, with scope intact, and with quality maintained," and in reality quality is shaved off in invisible places or cost is shifted onto burnout and rework. That is why, in discussing schedule compression, explicitly deciding first "what will be offered up as the price" is the starting point.

2. Overall structure and the decision procedure

Schedule compression starts from a state where network analysis (PERT/CPM) has fixed the critical path and float, identifies compression candidates, selectively applies crashing and fast tracking, and then re-evaluates the changed network in a cyclic structure. The overall flow is as follows.

flowchart TD
  BASE["Schedule baseline(network and critical path fixed)"] --> GAP["Delay analysis vs. target finish date"]
  GAP --> CP["Identify critical path and float"]
  CP --> CAND["Select compression candidates(on critical path)"]
  CAND --> CHOICE{"Choose compression method"}
  CHOICE -->|"Cost headroom available"| CRASH["Crashing(inject resources and cost)"]
  CHOICE -->|"Logical parallelization possible"| FAST["Fast tracking(process overlap)"]
  CRASH --> RECAL["Recompute network(re-identify critical path)"]
  FAST --> RECAL
  RECAL --> MEET{"Target met?"}
  MEET -->|"No"| CP
  MEET -->|"Yes"| CONFIRM["Confirm revised schedule and update baseline"]

The crux of this procedure is the {"Choose compression method"} branch. Where cost can be spent more freely but the work logic is hard to change (e.g., a process where approval and verification are mandatory), crashing is favorable; where the budget is tight but there is room to reinterpret the precedence relationships, fast tracking is favorable. In practice the two techniques are mixed, but the principle is to apply them starting from the activity whose price per unit of compression is smallest.

Unpacked into steps, the procedure is as follows. First, in the baseline-fixing step, compute the current network's critical path and each activity's float to nail down numerically how many days must be cut against the target finish date (the required compression). Second, in the candidate-selection step, keep only the activities on the critical path that can actually be shortened (those with crash headroom or logically parallelizable). Third, in the alternative-evaluation step, estimate each candidate's cost slope (crashing) and rework risk (fast tracking) to compare "the price per day of compression." Fourth, in the apply-and-recompute step, shorten by one unit the activity with the smallest price and recompute the network to check whether the critical path has changed. Fifth, repeat the second through fourth until the target is reached, and once reached, update the revised schedule as the official baseline. In this way the key point is that schedule compression is not a one-off calculation but an incremental optimization loop. The detailed procedure below shows the cost-slope-based selection logic of crashing.

flowchart TD
  START["Estimate required compression(e.g., 4 days)"] --> LIST["Survey crash feasibility per critical-path activity"]
  LIST --> SLOPE["Compute cost slope: (crash cost-normal cost)/(normal duration-crash duration)"]
  SLOPE --> SORT["Sort by slope ascending(cheapest activity first)"]
  SORT --> PICK["Shorten the minimum-slope activity by one unit"]
  PICK --> CHECK["Re-verify critical path"]
  CHECK --> MULTI{"Two or more critical paths?"}
  MULTI -->|"Yes"| PARALLEL["Multiple paths must be shortened together(sum the cost)"]
  MULTI -->|"No"| ENOUGH{"Target compression reached?"}
  PARALLEL --> ENOUGH
  ENOUGH -->|"No"| PICK
  ENOUGH -->|"Yes"| DONE["Confirm the minimum-extra-cost compression plan"]

3. Crashing — the quantitative model of the time-cost trade-off

Crashing is a technique that shortens duration by injecting extra resources (manpower, equipment, overtime, outsourcing) into critical-path activities. Its core premise is that each activity has a normal point (Normal: the most economical duration and cost) and a crash point (Crash: the shortest achievable duration and its cost), and that the space between them is approximated linearly. The extra cost of shortening by one unit of time is called the cost slope, computed as follows.

Cost slope = (crash cost − normal cost) ÷ (normal duration − crash duration)

The principle of crashing is best explained by example. Suppose a system-integration (SI) project's critical path has design (normal 10 days / 1.0M KRW, crash 7 days / 2.2M KRW) and development (normal 20 days / 3.0M KRW, crash 16 days / 5.4M KRW). Design's slope is (2.2M−1.0M)/(10−7)=0.4M KRW/day, development's is (5.4M−3.0M)/(20−16)=0.6M KRW/day. If the duration must be cut by two days, shortening the cheaper-slope design first by two days (extra 0.8M KRW) is more economical than shortening development (extra 1.2M KRW). In this way crashing reduces to an optimization problem that compares "which activity is cheapest to shorten per day" to find the combination that achieves the target duration at minimum cost.

Crashing's resource injection takes several forms. The most common is overtime, which can pull the duration in immediately without new hiring but, if prolonged, sharply degrades productivity and quality through fatigue accumulation. Next is adding manpower, which has a large effect but whose return on investment diminishes because of learning and communication costs and Brooks's Law. Third is outsourcing / bringing in specialist firms, suited to pushing out in parallel a specific task where internal capacity is lacking, but accompanied by management and handover overhead. Fourth is introducing high-performance equipment and automation tools, which raises the throughput of repetitive, mechanical work (builds, tests, data migration). Whatever the form, the key is to choose starting from the means with the lowest extra cost per unit of compression (cost slope), and the judgment that combines the four to fit the situation is what separates crashing skill.

That said, crashing has clear limits. First, diminishing returns. Doubling manpower does not halve the duration, and the paradox of Brooks's Law — "adding manpower to a late software project makes it later" — appears, because the learning and communication cost of new people offsets the gain in productivity. Second, compression beyond the crash limit is impossible. Activities exist that do not shrink however much resource is poured in, such as concrete curing, statutory notice periods, and external certification. Third, when multiple critical paths exist at once, all paths must be shortened together, so cost surges. Crashing is therefore evaluated as a compression means that is "costly but relatively controllable in risk."

4. Fast tracking — parallelizing sequential work

Fast tracking, which overlaps sequential work, starts from reinterpreting the nature of the dependency. When two activities bound by FS (finish-to-start) on the network are in reality not a mandatory dependency (hard logic) but a customary dependency (soft logic), that relationship can be changed to SS (start-to-start) plus a lead and overlapped. For example, if the constraint "development can start only after design is finished" is not a technical necessity but merely a familiar work order, room opens to change the logic so development begins from the confirmed parts of the design. Conversely, hard logic that physically requires the predecessor to finish — like painting after concrete curing — cannot be overlapped. Hence the first step of fast tracking is to examine the FS relationships on the critical path one by one and ask again whether they really must be sequential.

Fast tracking is a technique that shortens duration at almost no added cost by partially overlapping (SS relationship + lead) and performing in parallel activities originally planned in sequence (FS relationship). For instance, a plan that starts development only after design is 100% finished is changed so that "design and development proceed simultaneously from the confirmed modules." Starting excavation and foundation work in construction before basic design is finished, or parallelizing UI design and DB design in SI, are typical cases.

Fast tracking's greatest advantage is that it incurs almost no direct cost, because it only reinterprets the logic of the work order without buying extra resources. The price, however, appears as increased risk. Because the successor starts while the predecessor is incomplete, if the predecessor changes later, rework and correction cost arise in the successor. In the example above, if the design changes after development has started, already-written code must be torn up and reworked, and in the end both time and cost rise so that the compression effect can reverse. Fast tracking should therefore be applied first to segments where the predecessor is stable or has low change likelihood, and to activities with small rework cost, and it is safe to increase the degree of overlap gradually while observing the risk.

In practice fast tracking is in tune with the iteration and continuous integration (CI) of agile and DevOps. Slicing features small to overlap design-build-verify and catching the ripple of changes early with automated tests can substantially suppress the "large-scale rework from predecessor changes" that was feared in traditional waterfall. In other words, modern engineering practice functions as a structural device that lowers the risk of fast tracking.

When applying fast tracking, the practical knack is to adjust the degree of overlap in stages, coupled to risk. Split the predecessor activity's deliverable into a 'confirmed part / variable part,' overlap first only the successors that depend on the low-change-likelihood confirmed part, and start the successors that depend on the variable part only after the predecessor has stabilized. Also, always place an early-feedback channel (joint reviews by predecessor and successor owners, early freezing of interface specifications) in the overlapping segment, designed so that when a predecessor change occurs, the successor recognizes it immediately and minimizes loss. Without such devices, simply ordering "the schedule is urgent, so just overlap and do it" falls into the typical failure where the duration appears shortened on the surface but, just before the finish, large-scale integration defects and rework erupt and the actual duration in fact lengthens.

5. Comparison of crashing and fast tracking

The two techniques share the aim of "shortening the critical path," but what is paid as the price is fundamentally different. Crashing spends money (cost) to keep risk relatively low, while fast tracking saves money but shoulders rework risk instead. This difference determines which technique to use first depending on the project's constraints (is the budget tight, is quality sensitivity high).

Category Crashing (process compression) Fast tracking (process overlap)
Method Inject extra resources, overtime, outsourcing into critical-path activities Overlap sequential activities to run in parallel (FS→SS+Lead)
Added cost Increases (labor, overtime, outsourcing cost) Almost none (logic rearrangement)
Main risk Diminishing returns, quality degradation, burnout Adverse effect from rework and corrections
Apply first Processes with cost headroom and hard to parallelize Processes with tight budget and stable predecessors
Limits Crash limit, Brooks's Law Compression effect reverses on predecessor change
Selection metric Cost slope (minimum-cost combination) Rework probability, overlap risk

In real projects the two are mixed. For example, if some public system falls into a crisis of a two-month go-live delay, one overlaps design and construction with fast tracking in the infrastructure-build segment where change likelihood is low, and responds with crashing by adding skilled manpower in the business-logic development segment where frequent change is expected. The key is to apply the techniques separately to fit each segment's characteristics (change likelihood, rework cost, crash headroom) and, recomputing the network at every step, track the newly risen critical path.

A concrete numerical case lets us gauge the profit and loss of the mixed strategy. Suppose a 20-month project needs a two-month (about 10%) compression, and achieving this by crashing alone would take an extra 0.2 bn KRW per month over two months, totaling 0.4 bn KRW. If instead one month of the infrastructure segment is absorbed by fast tracking (almost 0 extra direct cost, but an expected rework cost of about 0.05 bn KRW) and only the remaining one month is handled by crashing (0.2 bn KRW), the same two months can be secured at around 0.25 bn KRW. If, on top of this, the liquidated damages for falling short are 0.3 bn KRW per month, then either way the benefit of compression outweighs the cost. In this way, converting benefits such as liquidated-damages avoidance and early revenue, and the crashing cost and fast-tracking rework cost, into the same monetary unit for comparison is a professional-engineer-level decision, distinguished from the linear judgments "just add more manpower" or "just overlap everything."

6. Advanced — resource constraints, agile, and optimization tools

Traditional CPM-based compression starts from the unrealistic assumption that resources are infinite. In reality, however, the same specialist is spread across several activities, so being parallelizable on the network does not mean the work can actually be done simultaneously. What bridges this gap is resource leveling and resource smoothing. Leveling adjusts the schedule so as not to exceed resource availability, allowing the finish date to extend, whereas smoothing adjusts only within the float range and keeps the finish date. Schedule compression must always be examined together with this resource constraint; otherwise it becomes a desk-bound schedule that is "shortened on the network but impossible to staff in reality." For this reason CCPM (critical-chain project management) defines a critical chain that reflects resource constraints and, by stripping the safety float of individual activities and pooling it into a project buffer, achieves compression and protection at the same time.

The pattern of application also differs markedly by industry. In construction and plant work, fast tracking is institutionalized as the 'design-build' approach, where starting civil and foundation work before the entire design is finished to cut months off the duration is close to standard. But if a design change collides with an already-built structure, large rework cost arises in the form of demolition and rebuilding, so design management that freezes changes early decides success or failure. In semiconductor fab construction and mass-production ramp-up, equipment move-in/hook-up is overlapped with process verification, and crashing that concentrates specialist engineers on bottleneck processes is combined to pull the mass-production date forward. In SI and public informatization, the go-live date is often fixed, so rather than compression, a strategy of splitting scope by period through 'phased go-live' is frequently run in parallel with crashing. In this way, which technique dominates diverges by industry according to the two variables the size of rework cost and the rigidity of the deadline.

In an agile environment the grammar of schedule compression changes. Because the basis is time-boxing, which fixes the iteration cycle and the invested resource (team) and adjusts scope by priority, the problem is redefined toward "completing the highest-value scope at the fixed point in time" rather than "pulling the finish date in." Even so, the mindset of fast tracking is deeply embedded in agile, because slicing into small units to overlap design-build-verify and absorbing integration risk early with CI/CD is precisely risk-controlled parallelization. Meanwhile, commercial scheduling tools (Primavera P6, MS Project) and linear-programming (LP) based optimization take the cost slope and resource constraints as input to automatically derive the minimum-cost compression combination, and recently the approach of pre-evaluating a compression plan's schedule risk (the completion-probability distribution) with Monte Carlo simulation is spreading. In other words, the manual time-cost calculation of the past is evolving into probabilistic decision-making that reflects even uncertainty.

7. Considerations and implications

From a professional-engineer perspective, schedule compression is not mere "going faster" but a managerial decision that integrally weighs cost, scope, quality, and risk, and the following must be considered comprehensively.

  • The repetitiveness of critical-path re-identification: Because shortening one path makes another the critical path, compression must presume a network recomputation at every step. The attitude of trying to finish with a single calculation is the most common cause of failure, and missing a hidden parallel critical path means the invested cost does not translate into a shorter finish date.
  • Managing the trade-off against quality and people: Excessive overtime in crashing invites a rising defect rate, burnout, and turnover, while excessive overlap in fast tracking explodes rework. The benefit of compression (avoiding liquidated damages, early revenue) and its hidden cost (rework, quality cost, maintenance burden) must be compared quantitatively and controlled so as not to cross the threshold line.
  • Distinction from scope reduction and descoping: The only true "free compression" is cutting scope, and that is not compression but the object of change control and stakeholder agreement. Strategies that renegotiate scope, like an MVP or phased release, must be handled separately from crashing and fast tracking to avoid confusion.
  • Designing risk buffers in parallel: Compression consumes the schedule's slack and makes the project fragile. Therefore CCPM's project and feeding buffers, contingency reserves for critical segments, and rework-suppression devices such as automated tests and configuration management must be designed together for the risk of compression to be controlled.
  • Alignment with contract and governance: In public and large SI, task changes and schedule changes are interlocked with contract, audit, and budget control. Compression decisions must be formalized through change-impact analysis (CR) and stakeholder approval procedures, and pulling the schedule in through informal nagging becomes the kindling for accountability and quality disputes.
  • Data-driven pre-validation and post-hoc learning: A compression plan should estimate the completion-probability distribution with Monte Carlo simulation to gauge in advance "what percentage chance this compression has of meeting the target date," and after completion should record the actual compression effect, extra cost, and rework volume as lessons learned to continually calibrate the organization's capability to estimate cost slopes and rework probabilities. Because compression is always made on a fresh estimate, the accumulation of past data directly leads to the compression accuracy of the next project.

References


In one line: Schedule compression shortens the critical path while preserving scope and quality; mix cost-spending crashing and rework-risk-bearing fast tracking to fit each segment's characteristics, re-identifying the critical path at every step and controlling the price quantitatively.