/
.webp)
The year was 2005. Damien Katz had a good job at IBM, a family to support, and a dangerous idea he could not let go.
He had spent years inside the belly of the Lotus Notes codebase — one of the most ambitious, sprawling, and frankly peculiar enterprise software projects in computing history. Notes was not a database. It was not an email client. It was not a document editor. It was all of those things simultaneously, built on a document-oriented storage model that sat two decades ahead of where the industry would eventually land. Katz had watched from the inside as that architecture — strange, ahead of its time, commercially encrusted — failed to reach its potential. He had a theory about why. And a theory about what should exist instead.
So he quit.
He moved his wife and kids to a cheaper city, drew down his savings, and began writing a database alone. No team. No funding. No roadmap. Just a conviction that the way people stored data on the internet was fundamentally broken, and that he could fix it.
He called it CouchDB. The name was an acronym — Cluster of Unreliable Commodity Hardware — though for years, the irony was that it ran on a single machine. The acronym was aspirational. A statement of intent about where databases needed to go, even if the software itself wasn't there yet.
He blogged the entire process in real time. Not polished retrospectives. The raw, grinding, often discouraging truth of building something hard from scratch. When he made progress, he wrote about it. When he hit walls, he wrote about those too. A small community of developers started following along — not because they needed what he was building yet, but because the project had the quality that the best open-source work always has: one person's obsession, conducted in public.
What Katz built over those two years would eventually power some of the largest applications on the internet. It would spawn a commercial company worth hundreds of millions of dollars. It would influence how the entire industry thought about offline-first architecture, document storage, and the rights of distributed systems to disagree with themselves.
It would also, in ways that say something true about how the tech industry actually works, end with Katz walking away from the thing he created.
To understand Couchbase, you have to understand that it was built from the collision of two entirely different problems being solved by two entirely different communities.
Damien Katz and the CouchDB Community
Katz's problem was philosophical. Relational databases — Oracle, MySQL, PostgreSQL — stored data in rigid rows and columns. They demanded that you define your schema before you wrote a single byte. They assumed consistency: the database would either make a change or it would not, and all readers would agree on what the current state was. This model worked beautifully for accounting systems, for inventory management, for anywhere that you needed a perfectly ordered record of truth.
But the internet didn't look like that.
The web was full of semi-structured information — user profiles that had some fields but not others, documents that evolved over time, content that needed to be read by millions of people simultaneously from servers scattered across continents. The relational model forced developers to torture their data into shapes it didn't naturally fit.
Katz's insight, deeply informed by his Lotus Notes years, was that a database should store JSON documents — arbitrary, flexible, schema-free objects — and should provide a way to query and index them without requiring a central gatekeeper enforcing consistency at all costs. CouchDB embraced something called eventual consistency: in a distributed system, different nodes could temporarily disagree about the current state of the data, as long as they had a principled way to resolve conflicts over time. The system favored availability over perfect consistency. If you needed to keep serving reads while a network partition happened, CouchDB let you do that.
For the implementation, Katz made a choice that became legendary in the developer community: he chose Erlang.
Erlang was a programming language invented by Ericsson in the 1980s for building telecommunications systems — specifically, systems that could not afford to go down. Phone switches that handled millions of calls. Systems where a software crash in one process could not be allowed to cascade into a system-wide failure. Erlang's entire design philosophy was built around the idea that processes should be isolated, failures should be contained, and the system should keep running even when parts of it broke.
For a database built to run on clusters of unreliable commodity hardware, Erlang's fault-tolerance model was theoretically perfect. Katz rewrote CouchDB from C++ to Erlang after struggling with conventional threading and concurrency, and found it — in his words — "fantastically productive."
The choice attracted a specific kind of developer. CouchDB's community was philosophical, idealistic, interested in the correctness of distributed systems, committed to open standards. They built REST APIs into the core, so that CouchDB could be queried with a plain HTTP request from any language, any platform, any device. They contributed PouchDB — a pure JavaScript implementation that ran inside a web browser, able to sync with CouchDB when online and continue operating when offline. This was the intellectual lineage that would eventually become the "offline-first" movement in web development, influencing how progressive web apps were designed for the next decade.
CouchDB was donated to the Apache Software Foundation in 2008, becoming an Apache top-level project. IBM, recognizing what Katz had built (and perhaps the irony of a former employee doing it), became a contributor. The circle had already started bending back toward its origin.
The NorthScale Team and the Zynga Problem
On the other side of the country, a different group of engineers was solving a different problem. Not philosophy — sheer, crushing, operational scale.
NorthScale was founded in 2009 by James Phillips, Steve Yen, and Dustin Sallings — engineers who were core contributors to Memcached, the open-source distributed memory caching system that had become the backbone of high-traffic web applications everywhere. Memcached was elegant: store frequently accessed data in RAM across a cluster of machines, avoid hitting your database on every request, survive at scale. But it had limits. Memcached didn't persist data. If your servers restarted, the cache was gone. And it had no native clustering — managing a Memcached deployment at very large scale was an operational nightmare.
The NorthScale team had a live test case for their new ideas, and its name was FarmVille.
Zynga's farming simulation game, launched on Facebook in June 2009, grew at a rate nobody had seen before. One million daily active users in four days. Ten million in sixty days. Seventy-five million monthly players within nine months. The write load was unlike anything typical web applications encountered — FarmVille was tracking millions of players' crop timers, inventory states, friend interactions, and farm layouts simultaneously, updating records with every click. The peak traffic between FarmVille's servers and Facebook hit roughly three gigabits per second. Standard database architectures buckled.
The NorthScale team, working with Zynga and South Korean internet giant NHN, built Membase — an open-source NoSQL database that put a persistent, clustered, replication-aware storage layer behind the Memcached protocol. Zynga could keep using the same client libraries they already had, but now the data would survive a server restart, could be replicated across nodes, and could scale horizontally as FarmVille added new servers. They open-sourced the project in mid-2010.
Membase was blunt-force engineering. Fast, operationally focused, built for the specific problem of handling enormous concurrent write volumes with low latency. Where CouchDB was philosophical, Membase was pragmatic. Where CouchDB embraced eventual consistency as a design principle, Membase was focused on getting the right answer into RAM as fast as possible. The two projects did not share a codebase, a language, or much of a worldview.
And then, in February 2011, they merged.
The announcement came quietly, as these things usually do — a press release, a blog post, a name: Couchbase, Inc.
CouchOne (the commercial company Damien Katz had formed around CouchDB) and Membase, Inc. (the NorthScale successor) had agreed to combine. Bob Wiederhold, Membase's CEO, would run the combined company. Damien Katz became CTO. They would build something that had neither company's products yet — a new database called Couchbase Server, combining Membase's high-performance clustering and replication engine with CouchDB's document model and flexible query capabilities.
What this meant, in practice, was that two communities with genuinely different philosophies had to find a way to share a project. CouchDB's people believed in the Apache way — open governance, consensus-based decision making, the primacy of the community over any commercial entity. Membase's people had been building for production operations teams who needed something that just worked, fast, at scale, without philosophical overhead.
The tensions were real, and they surfaced quickly.
Damien Katz was not well-suited to the role of commercial CTO in a venture-backed NoSQL startup fighting MongoDB for enterprise accounts. He was a builder. A thinker. Someone who had spent years developing strong opinions about database design and had the credibility — the ground-up creation of CouchDB — to defend them. But the merged company needed to move fast, sign enterprise deals, and make pragmatic engineering compromises that a purist would find uncomfortable.
In January 2012 — less than a year after the merger — Katz published a blog post that detonated quietly in the database community. He announced that he was stepping away from Apache CouchDB entirely to focus on Couchbase Server. He explained that the Apache consensus-based development process had made it difficult to respond to customer needs, that keeping the two codebases in sync was operationally painful, and that he had concluded Couchbase Server was the successor — not a fork, in his view, but the next iteration of what he had been trying to build.
He also dropped a line that landed hard for the people who had followed him since 2005: "I'd not have chosen Erlang if I knew what I know now."
The community responded with the mix of hurt, anger, and pointed criticism that open source communities reserve for founder departures. Till Klampaeckel, a longtime CouchDB contributor, put it plainly: "It's not the fact that Damien left, it's how he left." The perception was that Katz had made his creation look dead to the world in order to redirect developers toward a commercial product. Katz pushed back, arguing that no open source contributor owes indefinite maintenance to a project they've moved on from.
Apache CouchDB continued without him, eventually incorporating the BigCouch clustering technology from Cloudant — a company that took CouchDB in a different direction, building a cloud-hosted version that would later be acquired by IBM in 2014, completing the peculiar arc: the database born from a man who left IBM to build something better than IBM's Lotus Notes would eventually come back to IBM's ownership through a completely separate route.
Couchbase, meanwhile, pressed forward. The company secured $14 million in Series C funding in late 2011, then continued raising through subsequent rounds. They built N1QL — pronounced "nickel" — a SQL-like query language for JSON documents that gave developers familiar syntax for querying the unfamiliar document model. They built Couchbase Mobile: a version of the database that ran on iOS and Android devices, complete with a Sync Gateway that could synchronize offline data with a central server when a connection became available. Field service workers, airline crews, healthcare workers using tablets in hospitals — these were the enterprise use cases that Couchbase was uniquely positioned to serve.
The story of Couchbase's commercial success is less about a single eureka moment and more about a sustained bet on a problem that the industry was slow to acknowledge as real.
The bet was this: enterprise applications increasingly needed to work in conditions where consistent connectivity could not be guaranteed. A field technician inspecting equipment at a remote oil rig. A flight crew managing passenger data on an aircraft. A retail associate doing inventory in a basement with no WiFi. A doctor entering patient records on a tablet in a building with unreliable hospital WiFi. In every one of these scenarios, the industry's default answer — "require internet connectivity" — was either impractical or impossible.
Couchbase had built the infrastructure for this problem before the industry had fully articulated it. Couchbase Lite ran natively on mobile devices. Sync Gateway handled the complex, conflict-prone process of synchronizing offline writes back to a central database when connectivity resumed. The document model meant that each record could carry everything it needed — no joins, no foreign key lookups, no need for a connection to piece together a complete data object.
By 2015, Couchbase had landed customers like General Electric, Visa, McKesson, Office Depot, and Red Bull. Enterprise renewal rates held above 90%. The company was growing revenue at 20%+ annually. The original NoSQL community bet — that document-oriented, flexible-schema databases would eventually displace rigid relational models for a large class of applications — had proven correct. MongoDB was proving it most loudly, but Couchbase was proving it in the specific niche of high-performance, mobile-first, offline-capable enterprise applications.
Damien Katz left Couchbase entirely in 2013. He cited a simple truth: after eight years working on this problem, the company needed him far less than his family did. He eventually surfaced as a Senior Software Engineer at Amazon Web Services — a quiet exit for someone whose blog posts had once read like dispatches from a database frontier.
On July 22, 2021, Couchbase went public on the Nasdaq Global Select Market under the ticker symbol BASE — a choice so clean and declarative it felt like an act of confidence. The IPO priced at $24 per share, raising approximately $230 million in gross proceeds, led by Morgan Stanley and Goldman Sachs.
The timing was complicated. The database market had, by 2021, largely resolved into a two-tier structure. MongoDB had won the document database narrative so thoroughly that "NoSQL document store" and "MongoDB" had become nearly synonymous in many developer conversations. The cloud-native database market was consolidating around managed services — MongoDB Atlas, Amazon DynamoDB, Google Firestore — that abstracted away operational complexity and let developers focus on building.
Couchbase was not a small company by 2021. It had $123 million in annual revenue, an ARR approaching $133 million, and a customer roster that included some of the largest enterprises in the world. But it was also not MongoDB. It had chosen a harder market — the enterprise operational tier where deals were large and slow and technical — rather than the developer-adoption-first model that had made MongoDB a $30 billion company.
The post-IPO years were spent pivoting toward the cloud. Couchbase Capella, the company's fully managed DBaaS offering, launched in October 2021 and became the commercial focus. Performance benchmarks showed Capella outperforming MongoDB Atlas by significant margins on write-heavy workloads — the FarmVille DNA running in the product's veins, twenty years later. But performance alone had never been enough to move enterprise buying decisions, and Couchbase found itself doing what most public infrastructure companies do after their IPO: grinding toward profitability while defending existing customers and making the cloud transition case.
By fiscal 2023, revenue had grown to $154 million, ARR to $163 million. The numbers were respectable. They were not transformational.
Couchbase sits in an interesting position in the database landscape. It is not CouchDB — a fact that confuses developers new to the space and has required years of patient market education. It is not MongoDB — a comparison it courts in every benchmark but cannot escape in terms of brand recognition. It is not a startup anymore, but it is also not yet a dominant platform.
What it is, specifically, is the best-engineered solution for a specific class of hard problem: high-performance document storage for applications that need to work offline, on mobile, at edge locations, across distributed enterprise infrastructure. The airlines, healthcare systems, and field service companies that bet on it in 2013 and 2015 are still on it, still renewing, still building on the foundation that Damien Katz started drawing in his living room in 2005.
The man himself has been quiet since leaving. He works at AWS. He does not appear to have spent much time publicly relitigating the CouchDB years or his departure from Couchbase. Perhaps the most fitting description of his arc is the one written by the trajectory of the technology itself: a database built to store documents flexibly, survive failures gracefully, and keep running even when the network dropped — designed by someone who had learned, building it alone, that the work outlasts the person who starts it.
1. "Couch" was always supposed to be ironic.
The COUCH acronym — Cluster of Unreliable Commodity Hardware — was aspirational at the time of CouchDB's creation. The original CouchDB ran as a single-node database for years. The "cluster" capability Katz had imagined wasn't fully realized until Apache CouchDB 2.0 in 2016, when it incorporated BigCouch technology from Cloudant (which IBM had acquired). The name described a future that took over a decade to arrive.
2. Damien Katz originally built CouchDB in C++, then threw it away.
Before Erlang, there was a C++ prototype. Katz built a storage engine, view engine, and query language in C++, then hit a wall with conventional threading and locking under concurrent load. After reading about Erlang, he rewrote the entire thing — a decision he later partially reversed, saying in 2012 that he wouldn't choose Erlang again. He cited its small ecosystem, limited tooling, and the irony that Erlang — supposedly built for fault tolerance — required you to build your own watchdog processes to actually restart a crashed VM.
3. The FarmVille connection was a co-creation, not a customer story.
Zynga didn't buy Membase and scale FarmVille on it. Zynga helped build Membase. The open-source Membase project was announced in June 2010 as a joint effort between NorthScale, Zynga, and South Korean internet company NHN — all three contributed engineering resources and real-world production load to shape the project from its inception. FarmVille was not a case study for Membase. It was a founding collaborator.
4. CouchDB's spiritual successor ended up back at IBM.
Cloudant was a separate company that built BigCouch — a horizontally scalable, cloud-hosted version of CouchDB with proper clustering. It was, in many ways, what CouchDB had always been designed to become. IBM acquired Cloudant in 2014. The complete arc: Damien Katz learned document databases at IBM (Lotus Notes), left to build CouchDB, donated it to Apache, and the database's most important derivative ended up owned by IBM nine years later.
5. PouchDB — not Couchbase — may be Damien Katz's most durable legacy.
PouchDB, the JavaScript implementation of CouchDB that runs entirely in the browser, was built by a community that formed around Katz's original work. It enabled offline-first web applications before the term "progressive web app" existed — apps that write to local storage, sync to CouchDB when connected, and keep functioning when connectivity drops. The offline-first architectural pattern that PouchDB enabled is now a standard design consideration for any serious web application. Couchbase built a business. PouchDB changed how people think about building for the web.
Sources: Apache CouchDB documentation and history, Couchbase press releases, InfoQ interviews with Damien Katz (2008, 2012), TechCrunch merger announcement (February 2011), High Scalability FarmVille post-mortem, Couchbase S-1 and IPO filings (July 2021), myNoSQL/Alexander Popescu historical analysis, Erlang Factory speaker profiles (2009, 2011)
