How ARPANET Shaped Today's Internet: 7 Design Decisions

How ARPANET shaped today's internet: packet switching, the 1983 TCP/IP flag day, RFCs, DNS and end-to-end design, mapped to tools DevOps engineers use.

Jul 25, 2025 - 12:08
Nov 6, 2026 - 09:10
 0  80
How ARPANET Shaped Today's Internet: 7 Design Decisions

ARPANET shaped today's internet in four lasting ways: it proved packet switching works at scale, it moved to TCP/IP on 1 January 1983, it created the open RFC process that still defines internet standards, and it pushed intelligence to the end hosts instead of the network. Every ping, SSH session and DNS lookup you run inherits those choices.

This post looks at ARPANET from a working engineer's point of view. Instead of a long timeline, it traces specific design decisions from 1969 to 1990 and shows where each one appears in the tools you use on a Linux server or in a Kubernetes cluster today. If you want the layered model that grew out of this period, start with our pillar guide on what the OSI model is and why it still matters. For the wider question of which networks came before and alongside ARPANET, see the companion piece on the first networking system and how it shaped modern networks.

Key takeaways

  • ARPANET carried its first host-to-host message on 29 October 1969, between UCLA and SRI.
  • Packet switching came from independent work by Paul Baran at RAND and Donald Davies at the UK's National Physical Laboratory, who coined the word "packet".
  • The network switched from NCP to TCP/IP on 1 January 1983, a planned cutover described in RFC 801.
  • RFC 1 was published on 7 April 1969. The RFC series still publishes the standards behind TCP, HTTP and DNS.
  • The end-to-end idea (simple network, smart hosts) is why you can deploy new applications without asking your ISP.
  • ARPANET was decommissioned in 1990; NSFNET and commercial networks had already taken over its role.

A short, verified timeline

Dates matter here because many blog posts repeat them loosely. The table below sticks to milestones documented by the Internet Society, the IETF RFC archive and the original papers.

YearMilestoneWhy it still matters
1960sBaran (RAND) and Davies (NPL) describe packet switching independentlyData split into packets that travel independently is how every IP network works
1969 (April)RFC 1, "Host Software", by Steve CrockerOpen, numbered, public documents became the way protocols are agreed
1969 (Oct 29)First message from UCLA to SRI; the system crashed after "LO"Failure on the first try, then a fix, is still how networks get built
1969 (Dec)Four nodes: UCLA, SRI, UC Santa Barbara, University of UtahA small, heterogeneous network proved interoperability between different computers
1971Ray Tomlinson sends network email and picks the @ signuser@host addressing survives in every email address
1974Cerf and Kahn publish "A Protocol for Packet Network Intercommunication"The design that became TCP and IP, built to join different networks
1981RFC 791 (IP) and RFC 793 (TCP) publishedIPv4 header format is still defined by RFC 791; TCP is now RFC 9293 (2022)
1983 (Jan 1)ARPANET flag day: NCP turned off, TCP/IP requiredThe first large protocol migration with a hard deadline
1983 to 1987DNS designed by Paul Mockapetris (RFC 882/883, then RFC 1034/1035)Replaced the single HOSTS.TXT file with a distributed, delegated database
1990ARPANET decommissionedIts job passed to NSFNET and regional networks, then to commercial providers

Decision 1: packet switching instead of circuits

The telephone network reserved a circuit for the whole call. ARPANET did the opposite. Each message was cut into packets, and Interface Message Processors (IMPs), built by BBN, forwarded them hop by hop. If a link failed, packets could take another path.

Where you see it today:

  • Every IP router. Routers forward each packet based on its destination address, with no reserved path.
  • Load balancers and ECMP. Spreading flows across equal-cost paths only works because the network never promised one fixed circuit.
  • Retries in your code. Because packets can be lost, TCP retransmits and well-written services retry with backoff. The network was never designed to be perfect.

You can watch packet switching in action with two everyday commands:

# Show each router hop a packet takes to reach a host
traceroute example.com

# Measure round-trip time and packet loss
ping -c 5 example.com

If traceroute shows a different path on two runs, you are seeing the same flexibility ARPANET's designers wanted.

Decision 2: an internetwork, not one network

By the early 1970s ARPA was also funding packet radio and satellite networks. They used different hardware and could not talk to ARPANET directly. Vint Cerf and Bob Kahn's 1974 paper proposed a common protocol that ran on top of any network and used gateways (today we say routers) between them. That idea split into TCP for reliable delivery and IP for addressing and forwarding.

This "network of networks" idea is the literal meaning of "internet". It is also why a packet can leave your laptop over Wi-Fi, cross fibre, enter a cloud VPC and reach a pod network without any of those links knowing about the others. Our guide to the TCP/IP model with real-world examples walks through those layers, and OSI vs TCP/IP compared explains why the four-layer model won in practice.

Decision 3: a hard cutover to TCP/IP

ARPANET's original host protocol was NCP (Network Control Program). It assumed one network, so it could not carry traffic across gateways. The migration plan in RFC 801 set 1 January 1983 as the day NCP would stop working. Hosts that had not moved were cut off.

Lessons that DevOps teams still apply:

  • Announce the deadline early. RFC 801 was published in November 1981, more than a year ahead.
  • Run both stacks during transition. Hosts ran NCP and TCP/IP side by side before flag day. Dual-stack IPv4/IPv6 deployments follow the same pattern.
  • Accept that some systems will lag. Plan for stragglers instead of assuming 100 percent readiness.

Today's API deprecations, Kubernetes version removals and TLS 1.0 shutdowns are smaller versions of the same exercise.

Decision 4: open standards through RFCs

Steve Crocker wrote RFC 1 as a modest "request for comments" so nobody would feel the notes were final orders. That humble tone created a culture: anyone could propose, implementations were tested, and the best design won. The IETF formalised this process later, but the RFC series is unbroken from 1969.

Protocol you useCurrent defining RFCWhat it replaced or extended
IPv4RFC 791NCP-era host addressing
TCPRFC 9293Obsoletes RFC 793
DNSRFC 1034 and RFC 1035The single HOSTS.TXT file
FTPRFC 959Early ARPANET file transfer specs
IPv6RFC 8200Answer to IPv4 address exhaustion

When a DevOps engineer reads an RFC to settle an argument about HTTP status codes or TCP keepalive behaviour, they are using a tool ARPANET created.

Decision 5: smart hosts, simple network

ARPANET left most of the work, such as reliability, ordering and application logic, to the hosts. Saltzer, Reed and Clark later named this the end-to-end argument (1984). The network's job is to move packets; the endpoints decide what they mean.

That choice is the reason:

  • You can launch a new protocol (QUIC is a recent example) without replacing core routers.
  • Containers and service meshes add features like mutual TLS and retries at the edge, not in the switch.
  • Troubleshooting usually starts at the host: check the process, the port and the firewall before blaming the network.

Decision 6: names that scale (HOSTS.TXT to DNS)

Early ARPANET hosts used a single file, HOSTS.TXT, maintained centrally at SRI and copied to every machine. As hosts grew into the hundreds, keeping that file current became painful. DNS solved it by delegating authority: each organisation runs its own part of the namespace.

Two traces of this history sit on every Linux machine:

# The local hosts file still exists and is usually checked before DNS
cat /etc/hosts

# Query DNS directly, showing the delegation-based answer
dig +short example.com A

When a Kubernetes pod resolves my-service.default.svc.cluster.local, it is using the same delegated model, just inside a cluster.

Decision 7: remote access and file transfer from day one

Remote login (Telnet) and file transfer (FTP) were among ARPANET's first applications because the whole point was sharing expensive computers. Both sent data in clear text, which was acceptable on a small research network of trusted users.

Those protocols taught a lesson the hard way: trust assumptions do not survive growth. SSH replaced Telnet, and SFTP or HTTPS replaced most FTP use. If you manage servers, our guide on secure SSH access in Linux shows how far remote access has come, and ports and protocols every cloud engineer should know lists where those legacy services still lurk.

What ARPANET did not solve

An honest view of the legacy includes the gaps:

  • Security. Authentication and encryption were not part of the original design. TLS, SSH, IPsec and DNSSEC were added decades later.
  • Address space. IPv4's 32-bit address space looked huge in 1981. Exhaustion led to NAT, CIDR and IPv6.
  • Address conflicts. Manual addressing caused duplicates, a problem still common on LANs. See what happens when two devices share an IP address.
  • Congestion. TCP congestion control came after the "congestion collapse" events of 1986, when Van Jacobson's work added slow start and related algorithms.

From ARPANET to the cloud: a mapping

ARPANET conceptModern equivalentWhere a DevOps engineer meets it
IMP (packet switch)Router, virtual router, cloud route tableVPC routing, Kubernetes CNI
Host-to-host protocol (NCP)TCP and UDPService ports, health checks, TCP vs UDP choices
Gateway between networksInternet gateway, NAT gateway, VPNHybrid and multi-cloud links
HOSTS.TXTDNS, CoreDNS, cloud DNS servicesService discovery
RFC processIETF RFCs, also KEPs and open design docsReading specs, proposing changes
Flag day migrationPlanned deprecations and version removalsKubernetes upgrades, TLS policy changes

Why network history helps in a DevOps career

Knowing why TCP retransmits, why DNS is hierarchical and why the network does not guarantee delivery makes troubleshooting faster. When a service times out, you think in layers and in hops, not in guesses. These fundamentals are part of the Linux and networking modules in our Linux administration training and the networking basics covered in the DevOps training program, available in our Kharadi, Pune classroom and live online.

How to read the original documents yourself

Most of the dates in this post can be checked in a few minutes, because the RFC Editor keeps every RFC online as plain text. Reading the source is a good habit for any engineer who has to settle a protocol question.

# Fetch RFC 801 (the NCP to TCP transition plan) as plain text
curl -s https://www.rfc-editor.org/rfc/rfc801.txt | head -60

# Fetch the current TCP specification
curl -s https://www.rfc-editor.org/rfc/rfc9293.txt | less

RFC 801 states its goal plainly: a complete switch from NCP to IP/TCP by 1 January 1983. Each RFC page on rfc-editor.org also lists which documents it updates or obsoletes, so you can see, for example, that RFC 9293 obsoletes RFC 793. When a blog post (including this one) quotes a protocol detail, the RFC is the place to confirm it.

From address classes to CIDR

RFC 791 divided IPv4 addresses into classes. Class A networks used the first 8 bits for the network, class B used 16 and class C used 24. The scheme was simple, but it wasted addresses: an organisation that needed 2,000 addresses had to take a class B with about 65,000. As the internet grew past its research roots, routing tables also grew quickly.

Classless Inter-Domain Routing (CIDR), introduced in 1993 with RFC 1519 and updated by RFC 4632, replaced fixed classes with a prefix length written after a slash, such as 10.20.0.0/16. Routers could then summarise many networks as one route. Every cloud VPC and Kubernetes pod range you configure today uses CIDR notation. Our guide to CIDR notation and why it is used covers the arithmetic.

EraAddressing approachProblem it addressed
Early ARPANETSmall host numbers per IMPOnly a handful of hosts existed
1981IPv4 classes A, B and C (RFC 791)Joining many networks with one address format
1993CIDR (RFC 1519, later RFC 4632)Address waste and routing table growth
1996Private ranges (RFC 1918) with NATConserving public addresses
1998 onwardIPv6 (now RFC 8200)Long-term address exhaustion

Frequently asked questions

When was ARPANET created?

ARPA funded the project in the late 1960s. The first host-to-host message was sent on 29 October 1969 from UCLA to SRI, and four nodes were connected by December 1969.

Is ARPANET the same as the internet?

No. ARPANET was one network. The internet is many networks joined by TCP/IP. ARPANET became one of the first networks on the internet after the 1983 switch to TCP/IP.

Who invented packet switching?

Paul Baran at RAND and Donald Davies at the UK National Physical Laboratory developed the idea independently in the 1960s. Davies coined the term "packet".

What was the ARPANET flag day?

On 1 January 1983 ARPANET stopped supporting NCP and required TCP/IP. The plan was published in RFC 801 in November 1981.

When was ARPANET shut down?

ARPANET was decommissioned in 1990, after NSFNET and regional networks had taken over its role as a backbone.

What is RFC 1?

RFC 1, "Host Software", was written by Steve Crocker and published on 7 April 1969. It started the Request for Comments series that still defines internet standards.

Which ARPANET ideas matter most for DevOps engineers?

Packet switching, the TCP/IP layering, the end-to-end principle and DNS delegation. They explain retries, timeouts, service discovery and why most troubleshooting starts on the host.

References

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.