--- slug: feeding-buffer type: concept summary: "A time reserve where a non-critical path joins the critical chain, protecting the chain's next start from variation on the feeding path." created: 2026-05-21 updated: 2026-06-16 related: critical-chain: relation: depends-on note: "A feeding buffer can only be placed after the critical chain has been identified; the chain is the structure the buffer protects at each merge point." project-buffer: relation: complements note: "The project buffer protects the end of the critical chain, while feeding buffers protect the points where non-critical chains join it." resource-buffer: relation: contrasts-with note: "A feeding buffer is time on a non-critical path; a resource buffer is a notification signal and adds no time to the project plan." buffer-management: relation: uses note: "Feeding buffers are read through the same buffer-management discipline as the project buffer: remaining-time reports consume or recover buffer time." fever-chart: relation: informs note: "When a feeding buffer is fully consumed, the remaining overage moves into the project buffer that the fever chart reads." subordination: relation: implements note: "Feeding buffers are the CCPM subordination move for non-critical chains: they protect the critical chain's starts without treating every path as critical." padding-without-aggregating: relation: prevents note: "Feeding buffers move safety out of individual feeder tasks and into one visible reserve at the merge point." student-syndrome: relation: mitigates note: "Removing task-level safety from feeder tasks reduces the local margin that Student Syndrome consumes before work starts." parkinsons-law: relation: mitigates note: "Aggregating feeder-path safety into the feeding buffer reduces the task-level time that Parkinson's Law can expand into." --- # Feeding Buffer [TOC Fundamentals (TOCFC)](learning-tracks.md#toc-fundamentals): [prev: Project Buffer](project-buffer.md) -> Feeding Buffer -> [next: Resource Buffer](resource-buffer.md) [CCPM (CCPM Practitioner)](learning-tracks.md#ccpm): [prev: Project Buffer](project-buffer.md) -> Feeding Buffer -> [next: Resource Buffer](resource-buffer.md) > **Concept:** Vocabulary that names a phenomenon. *A time reserve placed where a non-critical chain joins the critical chain, protecting the chain's next start from variation on the feeding path.* *Also known as: feeder buffer.* A feeding buffer is Critical Chain Project Management's local protection at a merge point. A side path finishes late, joins the critical chain, and the project constraint waits. The project buffer protects the external due date at the end of the chain; it does not protect every merge along the way. Feeding buffers protect those joins before feeder variation reaches the chain. ## Context A [critical chain](critical-chain.md) project schedule has one chain that limits the project and several non-critical chains that feed into it. Those feeder paths may have slack relative to the critical chain, but they still matter. If a non-critical path joins the critical chain at a convergent point and finishes late enough, the next critical-chain task cannot start. The path that was "non-critical" is now delaying the constraint. CCPM treats that merge as a subordination problem. Non-critical work should not receive the same protection as the critical chain, because that would rebuild the old padded schedule. But it also can't be ignored. The [project buffer](project-buffer.md) at the end of the chain is too late a signal for a feeder path that is about to starve the chain today. The feeding buffer gives that path its own visible reserve before it can block the merge. The *TOCICO Dictionary* defines the feeding buffer as a time buffer between non-critical-chain work and the critical chain. Budd and Cerveny's *TOC Handbook* primer places it in Step 5 of the CCPM scheduling sequence, after the critical chain and project buffer are already in place. That order matters: the feeding buffer is not a second way to find the chain. It is protection added after the chain is known. ## What It Is The feeding buffer has five operational properties. **It is time, not inventory, money, or capacity.** A feeding buffer is a duration placed into the schedule at a merge point. It carries no task and no resource. It is empty calendar time that absorbs feeder-path variation before that variation reaches the critical chain. **It sits at a convergent point.** The buffer goes where a non-critical chain joins the critical chain. The *TOCICO Dictionary* uses *convergent point* for the task where two or more paths must complete before the successor can start; it uses *integration point* for major path convergence near the end of a project. In both cases the feeder path receives a time reserve before it can block the chain. **There can be many feeding buffers.** A project has one project buffer, but it may have several feeding buffers. Each one protects a different merge point. A project with three non-critical paths joining the chain can have three feeding buffers, each sized to the path it protects. **Its size comes from the feeding path, not from the whole project.** The practitioner rule in *TOC Handbook* Ch. 3 is to use the same sizing logic as the project buffer: roughly half the reduced task time on the feeding path. If the feeding path contains a critical-chain task, exclude that task; the project buffer already protects it. **Its insertion can force another resource-leveling pass.** Adding a feeding buffer may push feeder tasks earlier. That can create new resource contention with other tasks. Budd and Cerveny warn practitioners to expect that second pass and resolve it before treating the schedule as protected. A buffer that creates multitasking has protected the chain on paper and damaged it in execution. ## How It Is Measured or Recognized The feeding-buffer procedure starts with the finished critical-chain schedule. 1. **Find every path that merges into the critical chain.** Look for non-critical chains whose last task must finish before a critical-chain task can start. 2. **Place a buffer at the merge.** The buffer sits at the end of the feeding path, just before the critical-chain task it feeds. 3. **Size it from the feeding path.** Use the same aggregation logic as the project buffer: about half the reduced task time on the feeder path, excluding any critical-chain task already protected by the project buffer. 4. **Recheck resource contention.** If the buffer pushes feeder work earlier, level the resources again. Don't let the buffer create bad multitasking. 5. **Read it during execution by remaining time, not percent complete.** At each checkpoint, ask active task owners how much time remains. If a task on a feeding chain overruns its aggressive duration, debit the overage from the feeding buffer. If the feeding buffer is exhausted and overage remains, debit the rest from the project buffer. Recognition is straightforward: if a schedule has a non-critical path that joins the critical chain and there is no visible time reserve before that join, the schedule is missing a feeding buffer. If every non-critical path is padded task by task instead, the project has fallen back into [Padding Without Aggregating](padding-without-aggregating.md). ## Why It Matters Feeding buffers protect the critical chain without pretending every path is critical. **They preserve the chain's starts.** The critical-chain task after a merge should start when its predecessor on the chain is ready. A late feeder path should not make the chain wait until it has consumed the protection assigned to that merge. The feeding buffer gives the project manager that protection and makes its consumption visible before the chain is actually starved. **They keep the project buffer from doing all the work.** The project buffer is the final reserve for the whole chain. If every feeder-path delay lands directly in it, the fever chart becomes a late, aggregate signal and loses diagnostic detail. Feeding buffers catch feeder-path variation earlier and show which side path is creating the risk. **They distinguish the three CCPM buffer types.** Certification candidates and working project managers often lump the project buffer, feeding buffer, and resource buffer together. They aren't the same thing. The project buffer is one time reserve at the end of the critical chain. Feeding buffers are multiple time reserves at merge points. Resource buffers are notifications, not time reserves. Confusing the three produces schedules that look like CCPM but still behave like padded critical-path plans. **They make subordination concrete.** In projects, subordination means non-critical paths serve the critical chain's starts. Feeding buffers are the mechanism that lets a non-critical path carry enough protection to feed the chain without taking over the project's priority system. For TOCICO certification readers, the feeding buffer is one of the cleanest tests of whether a CCPM schedule is real. If the schedule has a named critical chain and a project buffer but no feeding buffers at merge points, it is unfinished. ## Common Misunderstanding **A feeding buffer is not slack.** Slack is the schedule difference between a non-critical path's early and late dates. A feeding buffer is deliberate protection placed at the merge point after task safety has been stripped and aggregated. Slack is discovered by schedule math; a feeding buffer is a CCPM design choice. **A feeding buffer is not the project buffer in miniature.** Both are time reserves, and both use the same aggregation logic, but they protect different things. The feeding buffer protects a critical-chain start from a feeder path. The project buffer protects the external project commitment from variation on the critical chain and from any feeder-path overage that survives its feeding buffer. **A feeding buffer doesn't justify starting every feeder path early.** CCPM usually starts tasks as late as practical to limit work-in-process and keep priorities clean. Feeding-buffer insertion may push a feeder path earlier, but that move is justified by protecting a merge point, not by the belief that earlier starts are always better. **A feeding buffer in red does not always require immediate escalation.** Budd and Cerveny distinguish feeding-buffer penetration from project-buffer penetration. If a feeding buffer is in red but the project buffer still holds adequate protection, the right move may be careful monitoring rather than intervention. If the project buffer is in red, the action plan starts. ## Sources - Cox, *TOCICO Dictionary* (2nd ed., 2012), entries "feeding buffer," "convergent point," "integration point," "project buffer," and "resource buffer" — the certification-grade definitions this entry cross-checks against. The Dictionary is distributed through TOCICO membership and doesn't carry an Open Library record. - Goldratt, [*Critical Chain*](https://openlibrary.org/works/OL8384933W) (1997) — the originating treatment of CCPM. Introduces the project buffer, feeding buffers, resource buffers, and relay-runner work behavior as one coordinated project-management mechanism. - Cox and Schleier, [*Theory of Constraints Handbook*](https://openlibrary.org/works/OL18346923W) (2010), Ch. 2 (Walker, "Problems with Project Management") — explains why PERT/CPM schedules fail under resource contention and task-time variation, then frames buffers as the protection mechanism CCPM adds. - Cox and Schleier, [*Theory of Constraints Handbook*](https://openlibrary.org/works/OL18346923W) (2010), Ch. 3 (Budd and Cerveny, "A Critical Chain Project Management Primer") — gives the Step 5 placement rule for feeding buffers, the sizing rule, the resource-contention warning after insertion, and the execution rule for debiting feeding-buffer overages before project-buffer overages. --- - [Next: Resource Buffer](resource-buffer.md) - [Previous: Project Buffer](project-buffer.md)