The real history of email, from a typo test to your inbox today
How email actually began: Ray Tomlinson's 1971 test message, the @ symbol he almost didn't use, SMTP, Hotmail, Gmail, and 55 years to today's inbox.
By David Lara, Founder
Founder-reviewed ·How we research and correct articles
The first email ever sent, in 1971, was a test message between two machines
that happened to sit a few feet apart in the same room. Its author couldn’t
remember the exact wording a few years later — he guessed it was probably
something like “QWERTYUIOP,” the top row of a keyboard, typed to see if the
system worked at all. Nobody photographed it. Nobody archived it. It wasn’t
supposed to matter. Fifty-five years later, more than 300 billion emails move
through the internet every single day, and the format of that address —
user@host — is still exactly how the inventor wrote it the first time. No
committee designed it, no company owns it, and no successor technology has
managed to replace it, which is a strange kind of staying power for
something a single engineer improvised on a Tuesday.
That’s a genuinely strange origin story for the technology half of the world still runs its work through, so here’s the real one, the parts that are verifiable and the parts that are still a little bit legend.
The man who wasn’t trying to invent anything
In 1971, Ray Tomlinson was an engineer at Bolt Beranek and Newman (BBN), the
contractor building the early infrastructure of ARPANET — the Defense
Department research network that would eventually become the internet.
Tomlinson wasn’t tasked with inventing email. He was working on two separate,
unrelated pieces of software: SNDMSG, a local program that let users on the
same time-sharing computer leave text messages for each other, and CPYNET,
an experimental file-transfer program for moving data between different
machines on the network.
The insight was combining them. If CPYNET could move a file to a different
computer, and SNDMSG could deliver a message to a mailbox, there was no
reason the message itself couldn’t be the file being moved. Tomlinson wired
the two together, and — according to the Internet Hall of Fame’s account of
his work — sent a test message to himself on a neighboring machine to check
it worked. It did. Person-to-person network email existed.
He then had to solve a smaller but oddly consequential problem: the address.
A message now needed to specify both who and where — a user, and the
specific machine that user’s mailbox lived on. Tomlinson needed a character
that would never appear in a real username, so there’d be no ambiguity about
where the name ended and the machine began. Looking at the keyboard in front
of him, he picked the @ symbol — mostly because it was already sitting
right there, doing nothing else useful on a computer keyboard in 1971, and it
read naturally as “at.” tomlinson@bbn-tenexa became the first address in
that shape. It’s the same shape every email address on Earth still uses.
Eight moments across 55 years — from a self-addressed test message to a legally required unsubscribe header.
Two years later, Tomlinson co-authored RFC 561 with two colleagues, the first
formal specification for what an email message should even contain —
From, Subject, Date. Fields you still see in every message header
today were standardized in 1973, before most of the people reading this were
born.
The plumbing that made it universal
Tomlinson’s invention worked, but it only worked inside ARPANET’s specific
network of machines. What turned “a clever hack at BBN” into a protocol every
mail server on Earth still speaks was the Simple Mail Transfer Protocol —
SMTP — standardized by Jon Postel as RFC 821 in August 1982. SMTP defined the
actual conversation two mail servers have when one hands a message to
another: HELO, MAIL FROM, RCPT TO, DATA. It’s a protocol old enough
to legally rent a car in most US states, and it is still, unmodified in its
basics, how a message physically travels from a sending server to a
recipient’s inbox in 2026.
The other quiet fix came a decade later. Early internet email could only reliably carry plain 7-bit ASCII text — no accented characters, no attachments, no images. MIME (Multipurpose Internet Mail Extensions), standardized in 1992, is the reason a message can carry a PDF, a photo, or text in any language at all. It’s invisible infrastructure most people never think about, which is exactly the mark of infrastructure that worked: SMTP moves the envelope, MIME defines what can legally be inside it, and neither one has needed a fundamental rewrite in the decades since, even as what people put inside that envelope changed completely.
From a terminal to a browser
For its first 25 years, email required an account on a specific machine and software installed to read it — genuinely inconvenient, and out of reach for anyone without institutional access to a university or research network. That changed on July 4, 1996, when Sabeer Bhatia and Jack Smith launched Hotmail — deliberately spelled with the capital letters HTML, a small joke about the language the service was built on. It was free, it worked in a browser, and it meant your inbox lived on the web instead of on one specific computer. Hotmail passed a million subscribers within about six months, and Microsoft bought it eighteen months after launch for roughly $400 million — a number that looked absurd for a free product until you noticed what “universal, free, browser-based email” was actually worth.
Gmail took the same idea and rebuilt the storage math underneath it. When Google announced Gmail on April 1, 2004, the headline detail was 1GB of free storage — roughly 500 times what competing webmail offered at the time, which was scarce enough that most people deleted old messages to make room for new ones. The number was so far outside expectations that a lot of the initial coverage assumed the whole announcement was an April Fools’ joke. It wasn’t. Gmail added conversation threading, fast search, and (eventually) the tabbed inbox that reorganized how promotional email gets read, which is a story with its own hinge point.
The other half of the story: abuse showed up almost immediately
Email’s dark twin arrived faster than most people assume. On May 3, 1978 — seven years after Tomlinson’s first message, and years before “spam” was even the word for it — a Digital Equipment Corporation marketer named Gary Thuerk sent an unsolicited promotional message to 393 ARPANET addresses, announcing an open house for DEC’s new VAX computers. It’s now widely regarded as the first unsolicited bulk email ever sent, complete with the same complaint every recipient still has today: nobody asked for this, and now it’s in my inbox.
The behavior existed before the word did. “Spam” as the name for unwanted bulk messages has its own strange path from canned meat to your junk folder — but the moment that made unsolicited commercial email a mainstream, front-page problem was April 12, 1994, when two immigration lawyers, Laurence Canter and Martha Siegel, posted an ad for their green-card lottery services to roughly 5,500 Usenet newsgroups at once. It became known as the “Green Card spam,” and it’s generally credited as the event that made “spam” the universally understood name for the problem, rather than a niche joke among the people who’d been annoyed by smaller incidents already.
That escalation, in turn, is what eventually produced federal legislation — the CAN-SPAM Act, signed into law in December 2003, which is its own chapter worth understanding on its own terms — and, decades later, the mandatory one-click unsubscribe requirements Gmail and Yahoo now enforce on every bulk sender.
The shape of the whole arc
1971 — a test, not a plan
Ray Tomlinson combines two unrelated programs to send a message between two machines in the same room, and picks @ almost by accident.
1978–1994 — abuse arrives, then gets a name
The first unsolicited bulk email predates the word 'spam' by 16 years; the Green Card spam of 1994 is what makes the term stick.
1982–1992 — the plumbing gets standardized
SMTP (1982) defines how servers hand off mail to each other; MIME (1992) lets a message carry more than plain ASCII text.
1996–2004 — the browser takes over
Hotmail proves free webmail works; Gmail resets expectations for storage, search, and what an inbox should feel like.
2003–2024 — the rules catch up
CAN-SPAM sets the first US federal floor; two decades later, Gmail and Yahoo make one-click unsubscribe a hard requirement, not a courtesy.
Why this history is worth knowing if you send email for a living
None of this is trivia for its own sake. Every constraint modern senders work inside — authenticate your domain, keep spam complaints low, make opting out effortless — exists because the open, trusting, permission-free system Tomlinson built in 1971 got exploited almost immediately and had to grow defenses decades later, one incident at a time. The protocol itself never got a redesign. It got a security and trust layer bolted onto a 55-year-old foundation, piece by piece, under pressure.
That’s precisely the layer Norbelys is built to handle for you. Email warmup exists because reputation, not protocol, is what actually determines inbox placement in 2026 — a problem nobody in 1971 needed to think about, because there were 393 possible recipients on the entire network. DMARC monitoring exists because SMTP, as designed, has no built-in way to prove who really sent a message — a gap closed decades after the protocol shipped, not inside it. And a compliant unsubscribe flow on every send is the direct descendant of the abuse that started in 1978 and hasn’t really stopped since.
If you’re sending cold email or running outreach campaigns in 2026, you’re operating on top of infrastructure whose default state is “open and unverified” and whose safety has always been added afterward, by senders who bothered to build it in. See how Norbelys handles domain warmup, authentication, and deliverability as one connected system, and start sending on infrastructure that was built knowing the whole history above — not rediscovering it the hard way on your own domain.