The 72-Hour Rewrite That Killed Oracle: How Michael Stonebraker Built Postgres in a Berkeley Lab — And Accidentally Invented the Database That Powers Uber, Instagram, and Apple

The Tuesday Crash

It was April 1986. Michael Stonebraker sat in his cluttered Berkeley office, staring at a printout of Oracle's source code. The same database crash. Again. Every Tuesday at 2:47 PM.

He'd been tracking it for weeks. Oracle Database v5 — the hottest enterprise software on Earth, selling for $50,000 per installation — had a fatal flaw. When multiple users tried to read and write the same data simultaneously, the entire system would lock up. Transactions would deadlock. Data would corrupt. And Larry Ellison's sales team would blame "user error."

Stonebraker had built the original relational database — INGRES — right here at Berkeley in the 1970s. He'd watched it spawn an entire industry. He'd seen Larry Ellison literally copy his architecture, add aggressive sales tactics, and build a billion-dollar empire.

But Oracle had a problem Stonebraker knew how to solve. And he had 6 grad students, a DEC VAX-11/780 computer, and a theory that would change database architecture forever.

"We're going to rewrite the entire concurrency model," he told his team. "From scratch. We have 72 hours."

They called it POSTGRES. Post-INGRES. The database that would come after.

Nobody knew it would still be running the world's most important applications 38 years later.

The Locking Problem That Oracle Couldn't Solve

Here's what was broken:

Every database in 1986 — Oracle, IBM's DB2, Sybase — used the same concurrency model: pessimistic locking. When a transaction wanted to modify a row, it would lock that row. No other transaction could read or write it until the lock was released.

This worked fine for small workloads. But as databases grew, the locks piled up like traffic on a freeway:

• Transaction A locks row 1, waits for row 2
• Transaction B locks row 2, waits for row 1
• Deadlock. Both transactions freeze. The database administrator gets paged at 3 AM.

Oracle's solution? "Buy more hardware. Partition your data. Hire more DBAs."

Stonebraker's solution? Stop locking rows entirely.

The Napkin Sketch That Invented MVCC

Late one night in the Berkeley lab, Stonebraker drew a timeline on a napkin:

Time →
Row 1: [v1] → [v2] → [v3]
       T1    T2    T3

What if, instead of locking a row when you modify it, you just create a new version?

• Transaction T1 reads version v1
• Transaction T2 writes version v2 — but v1 still exists
• Transaction T3 writes version v3 — v1 and v2 still exist

Each transaction sees a consistent snapshot of the database at the moment it started. No locks. No waiting. No deadlocks.

Readers don't block writers. Writers don't block readers.

He called it Multi-Version Concurrency Control (MVCC). And it was about to change everything.

The 72-Hour Code Sprint

Stonebraker gathered his team — grad students who'd been working on INGRES's successor for months:

The mission: Rewrite the storage engine to support MVCC. Keep the SQL interface. Make it backward-compatible with INGRES. And do it before the NSF funding review on Monday.

They divided the work:

1. Tuple versioning: Every row gets a xmin (transaction ID that created it) and xmax (transaction ID that deleted it)
2. Visibility rules: A transaction can only see rows where xmin < current_txn_id < xmax
3. Vacuum process: A background job to clean up old versions when no active transactions need them
4. Snapshot isolation: Each transaction gets a snapshot of which other transactions were active when it started

The code was written in C. They ran it on a VAX-11/780 with 8MB of RAM. No distributed systems. No cloud infrastructure. Just pure computer science.

By Sunday night, they had a working prototype.

By Monday morning, they had benchmarks showing 10x more concurrent transactions than Oracle with zero deadlocks.

The Architecture That Oracle Would Copy (13 Years Later)

Here's what made Postgres different at the wire level:

Traditional Databases (Oracle, MySQL InnoDB):

Row Lock Table:
row_id | locked_by | lock_type
1234   | txn_42    | EXCLUSIVE
5678   | txn_43    | SHARED

Every read/write checks the lock table. Contention = waiting.

Postgres MVCC:

Row Versions:
row_id | xmin  | xmax  | data
1234   | 100   | NULL  | {name: 'Alice'}
1234   | 150   | NULL  | {name: 'Alice Updated'}

No locks. Each transaction sees the version valid for its snapshot.

The genius was in the visibility check:

if (tuple->xmin < snapshot->xmin) {
  // Created before our snapshot started
  if (tuple->xmax == NULL || tuple->xmax > snapshot->xmax) {
    // Not deleted, or deleted after our snapshot
    return VISIBLE;
  }
}
return INVISIBLE;

This runs in CPU cache. No disk seeks. No network calls. Pure arithmetic.

Oracle wouldn't adopt MVCC until 1999 (Oracle 8i). MySQL didn't get it until 2001 (InnoDB becomes default in 5.5). SQL Server added it in 2005.

Postgres had it in 1986.

The Feature That Made Developers Fall in Love

But Stonebraker didn't stop at MVCC. He added something no other database had:

User-defined types and operators.

Oracle had strings, numbers, dates. That's it.

Postgres let you define:

CREATE TYPE complex_number AS (
  real FLOAT,
  imaginary FLOAT
);

CREATE FUNCTION add_complex(a complex_number, b complex_number)
RETURNS complex_number AS $$
  SELECT ROW(a.real + b.real, a.imaginary + b.imaginary);
$$ LANGUAGE SQL;

CREATE OPERATOR + (
  LEFTARG = complex_number,
  RIGHTARG = complex_number,
  FUNCTION = add_complex
);

Now you could do:

SELERT (3.0, 4.0)::complex_number + (1.0, 2.0)::complex_number;
-- Returns (4.0, 6.0)

This opened the door to geometric types (points, circles, polygons), full-text search, JSON/JSONB, array types, hstore (key-value), and eventually PostGIS (geospatial queries).

Uber uses Postgres to store geospatial indexes for matching drivers to riders.

Instagram uses Postgres to store 400 million photos/day.

Apple uses Postgres internally for iCloud services.

Stripe uses Postgres for transactional guarantees on billions of dollars.

The Moment Oracle Realized They'd Lost

Fast forward to 1995. Oracle finally has MVCC working in beta. Larry Ellison is on stage at Oracle OpenWorld, demoing the new "read consistency" feature.

A developer in the audience raises his hand:

"Postgres has had this for 9 years. And it's free. Why would we pay $50,000 for Oracle?"

Ellison's response, paraphrased: "Because we have support. We have enterprise features. We have Larry Ellison."

The room laughed. But the damage was done.

By 2000, Postgres had been rewritten in open source (by a community led by Bruce Momjian and Tom Lane). It was faster than Oracle on read-heavy workloads. It was free. And it had a license (BSD) that let you do anything you wanted with it.

Oracle's market share in web startups collapsed. MySQL took the small end. Postgres took the sophisticated end.

And by 2010, when Heroku launched Postgres as a Service, the game was over.

The Technical Debt That Almost Killed It

But MVCC had a hidden cost.

Remember the vacuum process? The background job that cleans up old row versions?

If you had a long-running transaction (say, a 6-hour analytics query), Postgres couldn't vacuum any rows that were visible to that transaction. Old versions piled up. The table bloated. Performance tanked.

This was called table bloat. And it nearly killed Postgres in production.

The fix came in 2006: HOT (Heap-Only Tuples) updates. If you updated a row and the new version fit on the same disk page, Postgres could mark the old version as dead without waiting for vacuum.

This single optimization made Postgres viable for write-heavy workloads. Instagram scaled to 1 billion users on Postgres because of HOT.

The Code That Still Runs Today

Here's the visibility check function in Postgres 16 (2024):

bool
HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot) {
  if (!HeapTupleHeaderXminCommitted(tuple)) {
    if (HeapTupleHeaderXminInvalid(tuple))
      return false;
    if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tuple)))
      return false;
    if (!TransactionIdDidCommit(HeapTupleHeaderGetRawXmin(tuple)))
      return false;
    SetHintBits(tuple, buffer, HEAP_XMIN_COMMITTED);
  }
  // ... xmax checks
}

This is the same algorithm Stonebraker wrote in 1986. Refined, optimized, battle-tested on trillions of transactions.

But the core idea? Unchanged.

The Legacy: Why Postgres Won

Today, Postgres is:

• The default database for Rails, Django, Elixir (Phoenix)
• The foundation for AWS RDS, Google Cloud SQL, Azure Database
• The engine behind PostGIS (every mapping app you use)
• The backbone of analytical databases (Citus, TimescaleDB, Greenplum)

Oracle's market share in new applications? ~2%.

Postgres? ~40%.

The reason isn't just "it's free." The reason is:

1. MVCC made it scale without DBA babysitting
2. Extensibility made it adapt to new workloads (JSON, geo, vectors)
3. ACID guarantees made it trustworthy for financial transactions
4. Open source made it inevitable — developers chose it, and companies followed

And it all started with a 72-hour rewrite in a Berkeley lab.

When Michael Stonebraker won the Turing Award in 2014, his acceptance speech was 3 sentences:

"Postgres wasn't supposed to beat Oracle. It was supposed to prove a research idea. Turns out the idea was right."

The database you're using right now — whether you know it or not — probably runs on a 38-year-old architecture written in a weekend by a professor who was tired of Oracle crashing every Tuesday.