The $500 Bluff That Built Microsoft: How Two College Kids Sold Software They Hadn't Written to the World's Biggest Computer Company

It was January 1975. Bill Gates sat in his Harvard dorm room, staring at the cover of Popular Electronics. The headline read: "World's First Minicomputer Kit to Rival Commercial Models... ALTAIR 8800."

He turned to his friend Paul Allen, who'd flown in from Boston. "We need to call them," Gates said. "Right now."

The problem? They didn't have any software to sell. They didn't own an Altair. They'd never even seen one. But that wasn't going to stop them from making the most audacious cold call in tech history.

The Machine That Shouldn't Have Mattered

The Altair 8800 was, by most accounts, a terrible computer. It had 256 bytes of memory (not kilobytes — bytes), no keyboard, no monitor, and no software. You programmed it by flipping toggle switches on the front panel in binary. If you made a mistake, you started over.

It cost $397 as a kit. MITS (Micro Instrumentation and Telemetry Systems), the Albuquerque company that made it, expected to sell maybe 800 units total. They sold 4,000 in the first three months.

But the Altair had one thing going for it: it used Intel's new 8080 microprocessor. And Bill Gates realized something nobody else had yet: a microprocessor was just a computer waiting for software.

Without software, the Altair was a $400 box of blinking lights. With software — specifically, with a programming language like BASIC — it could actually do something. And whoever owned that software would own the entire personal computer revolution that was about to happen.

Gates knew this. MITS didn't. Not yet.

The Cold Call

On a freezing January morning, Gates called MITS headquarters in Albuquerque from his dorm room. Ed Roberts, the founder and president of MITS, picked up.

"We've got BASIC for the Altair," Gates said. He was 19 years old and trying to sound older. "We're almost done. We'd like to demonstrate it."

Roberts was skeptical. He'd gotten dozens of calls from people claiming they had software for the Altair. None of them had delivered. Most were hobbyists who'd never written a real interpreter. Some were con artists.

But Gates had something the others didn't: confidence, technical depth, and a partner who actually knew what he was talking about. Paul Allen got on the line and started explaining the technical approach — how they'd handle memory constraints, how they'd implement floating-point arithmetic, how they'd fit a BASIC interpreter into 4K of RAM.

Roberts was impressed despite himself. "Fine," he said. "Come out to Albuquerque. Show me it works. If it does, we'll talk."

Gates hung up the phone. Allen looked at him.

"So," Allen said. "I guess we should start writing it."

The 8-Week Sprint That Changed Everything

They had a problem. Actually, they had several problems:

1. They didn't own an Altair 8800 (they cost $400, which neither of them had)
2. They didn't have access to an Intel 8080 chip to test on
3. They'd never written an interpreter before
4. Gates was supposed to be attending classes at Harvard
5. They had maybe 8 weeks before Roberts would expect a demo

Allen's solution was characteristically clever: he'd write an emulator. They'd simulate the Intel 8080 on Harvard's PDP-10 mainframe, then write the BASIC interpreter as if they were running on a real Altair. If the emulator was accurate, the code would work on the real hardware. If it wasn't, they'd fly to Albuquerque with software that would crash in the first 30 seconds.

Allen spent three weeks writing the emulator. He worked from the Intel 8080 specification manual, implementing each instruction, each flag, each memory operation. He had no way to verify it was correct. He just had to trust the math.

Meanwhile, Gates started writing BASIC. He'd lock himself in the Harvard computer lab for 36-hour sessions, surviving on pizza and Coca-Cola, writing code in assembly language on yellow legal pads. Then he'd type it into the PDP-10, compile it, run it through Allen's emulator, and watch it crash.

They had no version control. No debugger. No stack traces. When something broke, Gates would stare at pages of hexadecimal output trying to figure out which of the 8,000 lines of assembly code had a typo.

The Impossible Constraints

The hardest part wasn't the coding — it was the size. The Altair had 4K of RAM. That's 4,096 bytes. Their BASIC interpreter had to fit in that space, along with any program the user wrote, along with the runtime memory, along with everything.

To put that in perspective: this sentence you're reading right now is 286 bytes. The entire interpreter had to fit in the space of 14 sentences.

Gates became obsessed with optimization. Every byte mattered. He'd rewrite functions ten times to save three bytes. He'd hand-optimize the assembly output, replacing sequences of instructions with shorter equivalents. He'd find ways to reuse the same code path for multiple operations.

He wrote a floating-point math library from scratch because the standard approaches were too big. He wrote a memory allocator that used a single-pass algorithm to avoid fragmentation. He wrote a tokenizer that compressed BASIC keywords into single bytes to save space.

When they were done, the interpreter was 3.2K. They had 800 bytes left over for user programs. It was the most efficient code Gates would ever write.

The Flight to Albuquerque

On February 28, 1975, Paul Allen boarded a plane to Albuquerque. He carried a yellow paper tape with the BASIC interpreter punched into it — 8 weeks of work, stored as holes in a roll of paper.

He'd never tested the code on a real Altair. Nobody had. They'd run it thousands of times on the emulator, but emulators could have bugs. If Allen's emulator was wrong — if he'd misread a single flag in the Intel spec, if he'd implemented one instruction incorrectly — the whole thing would fail.

On the flight, Allen realized they'd forgotten something. The Altair needed a bootstrap loader — a tiny program that would read the paper tape and load BASIC into memory. They'd been so focused on writing the interpreter that they forgot to write the loader.

Allen pulled out a notebook and started writing assembly code on the plane. When he landed in Albuquerque, he went straight to MITS headquarters and asked to use their equipment. He hand-assembled the bootstrap loader, punched it into a paper tape, and only then realized: he still didn't know if any of this would work.

The Demo That Almost Didn't Happen

Ed Roberts led Allen into a room with an Altair 8800 sitting on a table. Roberts was a gruff ex-Air Force officer who didn't suffer fools. He'd seen dozens of people fail this exact demo.

Allen loaded the bootstrap. It worked. His hands were shaking.

He loaded the BASIC interpreter from the paper tape. It took three minutes. The Altair's lights blinked in patterns as it read each byte. When it finished, the lights stopped.

Allen typed on the teletype (they'd borrowed one for the demo):

PRINT 2+2

The Altair thought for a moment. The teletype clacked to life:

4

Roberts leaned forward. "Do something harder."

Allen wrote a program to calculate prime numbers. It worked. He wrote a program to do floating-point division. It worked. He wrote a program that would have crashed any other interpreter in 4K of memory. It worked.

Roberts stood up. "How much do you want for it?"

Allen said they'd discussed a licensing deal — MITS would pay royalties on every copy. Roberts offered $3,000 upfront plus $30 per copy sold. They shook hands.

Paul Allen called Bill Gates from a paycheck phone. "It worked," he said. "We have a deal."

Gates didn't say anything for a moment. Then: "Holy shit."

The Company That Started With a Typo

They needed a company name. Gates wanted "Allen & Gates," but Allen thought it sounded like a law firm. They tried "Micro-Soft" — a combination of microcomputer and software. Later they'd drop the hyphen.

The first Microsoft office was a two-room suite in Albuquerque, above a bank. Gates dropped out of Harvard (he'd tell his parents it was "temporary"). Allen quit his job at Honeywell. They hired a secretary and started recruiting programmers.

MITS sold 6,000 Altairs in 1975. Microsoft got $30 per unit — $180,000 in revenue. But most Altair owners never bought BASIC. They copied it from friends, or downloaded it from hobbyist bulletin boards. Software piracy was rampant.

Gates was furious. He wrote an open letter to hobbyists, published in Computer Notes: "Who can afford to do professional work for nothing? What hobbyist can put 3-man-years into programming, finding all bugs, documenting his product and distribute for free?"

The backlash was immediate. Hobbyists thought software should be free. Gates thought programmers deserved to be paid. This philosophical war would define the next 50 years of the software industry.

The Bet That Won

But Gates had already seen the future. It wasn't hardware. Hardware would become a commodity. The real value was in software — and specifically, in owning the software layer that everyone else would build on top of.

In 1980, IBM came calling. They needed an operating system for their new personal computer. Microsoft didn't have one, but Gates knew someone who did: Seattle Computer Products had written QDOS (Quick and Dirty Operating System) for the 8086 chip. Microsoft bought the rights for $50,000, renamed it MS-DOS, and licensed it to IBM.

The key move? Gates convinced IBM to let Microsoft license DOS to other companies. IBM said yes — they didn't think software mattered. They were wrong.

By 1985, dozens of computer manufacturers were paying Microsoft to license MS-DOS. By 1990, Microsoft was worth $1.2 billion. By 2000, it was worth $600 billion.

All because two college kids made a cold call, wrote 3.2K of assembly code in 8 weeks, and convinced the world that software was worth paying for.

The Legacy: The Bluff That Changed Everything

The Altair BASIC demo wasn't just Microsoft's origin story. It was the moment when software became a product — something you could sell, own, and build a company around.

Before 1975, software was something you got for free with the hardware. After 1975, software was an industry. Gates didn't invent that idea, but he proved it could work.

The bluff itself became Silicon Valley legend: the art of selling something before you've built it, of betting everything on your ability to deliver, of saying "yes" first and figuring out how later. Every startup pitch that starts with "we're almost done" is channeling Bill Gates in that Harvard dorm room.

Paul Allen would leave Microsoft in 1983 after being diagnosed with Hodgkin's lymphoma (he'd survive and live until 2018). Bill Gates would become the richest person in the world. Microsoft would dominate computing for 30 years, make a thousand millionaires, and shape how every human on Earth interacts with technology.

But it all started with a $500 bluff, a paper tape on a plane, and 3.2K of code that nobody was sure would work.

Ed Roberts, for his part, sold MITS in 1977 for $6 million and became a doctor. He'd later say the best decision he ever made was taking that phone call from a nervous 19-year-old who claimed he had software for a computer nobody owned yet.

The second-best decision? Actually letting him try to prove it.