In 1986, the internet backbone slowed down by 99.9 percent
Between 1986 and 1988, the infant internet suffered repeated congestion collapses. Across a critical backbone link between Berkeley and Lawrence Berkeley Laboratory, data transfer speeds plummeted from 32,000 bits per second to just 40 bits per second. Packets were dropped, causing sending computers to retransmit aggressively and swamp the network. Computer scientist Van Jacobson halted the panic loops by creating TCP congestion control, introducing the slow-start algorithm that still stabilizes internet traffic today.
The Day the Data Stopped Moving
In October 1986, the young network that would become the global internet hit a wall. Across a primary backbone connection spanning a short distance between the University of California, Berkeley, and the Lawrence Berkeley Laboratory, data transfer rates collapsed. A link capable of carrying 32,000 bits per second ground down to an agonizing 40 bits per second. The effective bandwidth had fallen by more than 99.8 percent, rendering the route virtually unusable for researchers trying to exchange information.
This phenomenon was not caused by a severed cable, physical hardware damage, or a software crash. Instead, it was an early and dramatic demonstration of what network engineers call congestion collapse. The underlying communication links were operating at maximum capacity, yet almost none of the data arriving at the destination was useful. Routers along the path were overwhelmed by traffic, and the network spent its energy processing doomed transmissions rather than delivering real work.
The Blind Spot in Early Network Design
To understand why the network collapsed, one must understand how early versions of the Transmission Control Protocol (TCP) handled traffic. Early TCP was equipped with flow control, a mechanism designed to prevent a fast sender from overwhelming a slow receiver. The receiving machine told the sender how much spare memory it had available—known as the advertised receive window. As long as the receiver had empty buffer space, the sender was free to transmit data as quickly as possible.
The critical flaw was that early TCP had no concept of the network between those two end points. The path between two machines consists of multiple intermediate routers, switches, and physical cables, each with limited memory and fixed data carrying limits. If two computers communicated through a chain of routers, the sender only cared about whether the final computer could accept data. Senders paid no attention to whether the intermediate routers along the path were drowning under heavy traffic.
When an intermediate router received more packets than its queue could hold, it had no choice but to discard the excess. The sending computer, noticing that the receiver never acknowledged these missing packets, assumed they were lost in transit. Early TCP stacks responded by resending the unacknowledged data as fast as possible. This created a catastrophic positive feedback loop: the network became congested, packets were dropped, senders retransmitted even more aggressively, and the intermediate routers fell further behind, dropping nearly everything.
The Packet Conservation Principle
Faced with recurring collapses between 1986 and 1988, computer scientist Van Jacobson set out to diagnose the root mechanics of internet traffic. Jacobson observed that a network connection running at steady state ought to obey what he termed the packet conservation principle. Under this principle, a sender should not inject a new data packet into the network until an older packet has successfully completed its journey and exited the system.
In an ideal system, acknowledgments (ACKs) sent back by the receiver act as a natural regulator or clock. When the destination computer receives a packet, it emits an ACK. That ACK travels back to the sender, signaling that a unit of data has left the pipe. By linking the transmission of new packets to the arrival of returning ACKs, a sender naturally matches its transmission rate to the capacity of the slowest link on the route.
However, Jacobson recognized that systems rarely start in a steady state. When a connection opens, or after a severe interruption, the sender has no returning ACKs to pace its transmissions. Without a mechanism to discover the available capacity of the path, a sender could easily swamp an empty bottleneck on the very first round trip, triggering immediate packet drops.
Slow Start and Congestion Avoidance
To put packet conservation into practice, Jacobson introduced two interconnected mechanisms that were later formalized in RFC 2001: Slow Start and Congestion Avoidance. These algorithms introduced an internal variable on the sender called the congestion window (cwnd), which works alongside the receiver's advertised window to strictly limit how many unacknowledged bytes can be in flight across the network.
Slow Start governs how a connection begins. Rather than blasting the full capacity of the receiver window into a newly opened connection, the sender starts small, typically setting cwnd to one or two maximum segment sizes (MSS). For every acknowledgment that returns from the receiver, the sender increases cwnd by one segment. Because each ACK permits the release of two new packets, the effective sending window doubles during every round-trip time. Despite its name, Slow Start actually increases transmission speeds exponentially, allowing the connection to quickly ramp up and probe how much data the path can support.
To keep this exponential expansion from overshooting router capacity and causing a crash, the algorithm relies on a threshold value called ssthresh (slow start threshold). Once cwnd reaches or exceeds ssthresh, the sender transitions from Slow Start to Congestion Avoidance. In this phase, the growth switches from exponential to linear. Senders increase cwnd by roughly one segment per round-trip time, regardless of how many individual ACKs arrive. By inching forward segment by segment, the sender gently explores whether extra bandwidth has become available without suddenly flooding router queues.
Surviving Loss: Fast Retransmit and Fast Recovery
Even with careful probing, networks experience congestion and dropped packets. In Jacobson's framework, packet loss is treated as the primary signal that an intermediate queue has filled up. Early implementations relied on a retransmission timer: if an ACK did not arrive before the timer expired, the sender assumed catastrophic congestion, reset ssthresh to half of the current window, slashed cwnd back to a single segment, and restarted the Slow Start cycle from scratch.
While safe, waiting for a timer to expire wasted valuable time, especially when only an isolated packet was lost rather than the entire pipeline. To address this, RFC 2001 outlined the Fast Retransmit and Fast Recovery algorithms. When an intermediate router drops a single packet while subsequent packets make it through, the receiver generates duplicate acknowledgments for the last successfully ordered packet it saw. Senders take the arrival of three duplicate ACKs as an unmistakable clue that a specific segment went missing.
Under Fast Retransmit, the sender immediately retransmits the missing segment without waiting for the timer to elapse. It then enters Fast Recovery. Because duplicate ACKs prove that data is still successfully traversing the path and reaching the destination, the sender does not drop its window down to one segment. Instead, it cuts ssthresh in half and maintains a reduced window, allowing packets to keep flowing at a steady pace while the missing data is resolved. This combination of additive increase and multiplicative decrease (AIMD) established a mathematically stable balance across competing traffic streams.
The Bedrock of the Modern Internet
The introduction of TCP congestion control completely transformed internet engineering. Following the deployment of Jacobson's algorithms in standard operating system networking stacks in the late 1980s, the catastrophic congestion collapses that plagued the early internet were brought under control. The four core algorithms—Slow Start, Congestion Avoidance, Fast Retransmit, and Fast Recovery—allowed the network to scale by orders of magnitude over the following decades without requiring routers to explicitly negotiate bandwidth with every passing connection.
Although modern networking has produced newer congestion control variations tailored to high-speed fiber, wireless environments, and massive cloud data centers, the principles laid out in RFC 2001 remain foundational. By shifting the responsibility of traffic pacing onto the end devices and treating packet loss as a measure of path capacity, early internet architects built a self-stabilizing system capable of surviving exponential global growth.
Key takeaways
•Congestion collapse in early networks occurred because TCP only regulated speeds based on the receiver's memory, ignoring intermediate router capacities.
•The packet conservation principle ensures stability by requiring that a new packet is only injected into the network when an acknowledgment confirms an older packet has departed.
•Van Jacobson's algorithms use exponential growth (Slow Start) to discover bandwidth rapidly, switching to linear growth (Congestion Avoidance) to probe capacity safely.
•Fast Retransmit and Fast Recovery detect isolated losses using duplicate acknowledgments, maintaining active data flow without resorting to costly timeouts.