A brief history of email
Email is older than the internet. It predates the World Wide Web by over two decades. And many of the frustrations people experience with email today trace directly back to decisions made in the 1970s — when computers filled entire rooms and "networking" meant connecting a handful of research institutions.
Before the @: Early messaging systems
The idea of leaving electronic messages for other users existed before networked email. In 1965, researchers at MIT developed a program called "MAILBOX" that allowed users on the same time-sharing computer to leave messages for each other. Similar systems appeared at other institutions — but these early systems only worked within a single machine. You could message someone, but only if they used the same computer you did.The real breakthrough required networks.
1971: Ray Tomlinson and the @ symbol
In 1971, a programmer named Ray Tomlinson was working on ARPANET — the U.S. Department of Defense network that would eventually evolve into the internet. Tomlinson figured out how to send messages between different computers on the network, not just within the same machine.He needed a way to distinguish "user on this computer" from "user on that computer." He chose the @ symbol — a character that wasn't commonly used in names and clearly separated the username from the machine name. The format user@computer was born, and it remains the standard over fifty years later.
Tomlinson later admitted he couldn't remember what he wrote in that first networked email. It was probably something like "QWERTYUIOP" — a test message, not a historic proclamation. The significance only became clear in retrospect.
The 1970s: Rapid evolution, zero standards
Throughout the 1970s, email systems proliferated across ARPANET. Different institutions developed their own programs with their own commands and conventions. There was no universal standard for how to format a message, how to reply, or how to forward.In 1975, John Vittal created MSG, the first email program with features that seem obvious today: the ability to reply to a message and forward it to someone else. Before MSG, if you wanted to respond to an email, you had to manually copy the relevant text and compose a new message. Vittal automated this — and in doing so, established conventions that persist to this day.
Physical mail as the blueprint
Early email designers faced a challenge: how should this new medium work? With no digital precedent, they looked to physical mail.The terminology reflects this directly. "Inbox" and "Outbox" came from the physical trays on office desks. "CC" stands for Carbon Copy — the thin carbon paper office workers placed between sheets to create duplicates. "BCC" (Blind Carbon Copy) was for copies the primary recipient wouldn't know about. "Drafts" was where unfinished letters sat. "Archives" was the storage room.
These metaphors made email intuitive for users in 1975. But they also embedded assumptions about how messaging should work — assumptions that don't necessarily apply to digital communication.
1982: SMTP becomes the standard
By the early 1980s, the chaos of incompatible email systems needed resolution. In 1982, Jonathan Postel and others defined the Simple Mail Transfer Protocol (SMTP) in RFC 821. This standard specified exactly how email servers should talk to each other when sending messages.SMTP was designed for reliability in an era of unreliable networks. It prioritized getting messages delivered even when connections dropped, servers went offline, or routing paths changed. It succeeded remarkably well at this goal — email became one of the most reliable forms of digital communication.
But SMTP was designed for a different world. A world where everyone on the network was a trusted researcher. A world where bandwidth was precious and messages were plain text. A world where security meant physical access control, not cryptography. Many of email's modern problems — spam, phishing, spoofing — stem from SMTP's trusting origins.
Architectural decisions that still haunt us
Several choices from the 1970s and 80s continue to shape (and limit) email today:No native authentication: SMTP allowed anyone to claim to be anyone. The "From" address was just text you typed in. This made email trivially easy to spoof and enabled the spam epidemic that followed.
Text-first design: Email was built for plain text. Attachments, HTML formatting, and rich media were bolted on later through extensions like MIME (1996). These additions work, but they're layers on top of a system never designed for them.
Flat organization: The inbox was modeled on a physical tray where letters pile up. There was no concept of categorization, priority, or automatic organization — those were left for humans to do manually, or for future clients to attempt.
The people who shaped email
Ray Tomlinson (1941–2016): Sent the first networked email and introduced the @ symbol. Worked at BBN Technologies on ARPANET.John Vittal: Created MSG in 1975, introducing Reply and Forward — features so fundamental they're now invisible.
Jonathan Postel (1943–1998): Edited the RFCs that defined SMTP and many other internet standards. Known for Postel's Law: "Be conservative in what you send, be liberal in what you accept."
Dave Crocker: Contributed to email standardization for decades, authoring key RFCs on email architecture and format.
Why this history matters
Email wasn't designed. It evolved — through constraints, workarounds, and incremental additions. The architectural choices made when networks had a few hundred users now govern a system used by billions.Many email clients today still operate within these inherited constraints. They organize messages the same way, display threads the same way, and expect users to manage their inbox the same way people did in 1985.
Understanding this history explains why email feels the way it does — and why improving it requires more than surface-level changes.