TL;DR — Snowflake was founded in July 2012 by database-kernel insiders who spent two years in stealth building a closed product on a blank sheet. Databricks was incorporated in June 2013 by seven academics around an open-source project already famous before the company existed. Neither was wrong, and almost every difference since — architecture, pricing, go-to-market, even the tone of their blog posts — was already encoded in those two choices.
Rivalries usually start with a product collision. This one started with a philosophical one, three years before the two companies ever appeared on the same slide.
In 2012 and 2013, two small groups looked at the same fact — cloud object storage was cheap, elastic, and nobody's data warehouse was built for it — and drew opposite conclusions. One built a new database from scratch and kept it secret until it worked. The other built the company around code that already had users. Everything downstream — warehouse versus lakehouse, consumption pricing, the benchmark wars, the AI-era land grab — follows.
The concepts you need
Cloud-native from scratch vs. retrofitted to cloud. A pre-cloud warehouse ties disks and CPUs to the same fixed machines: grow one and you grow the other, and every query fights every other for both. Lift it onto AWS unchanged and you keep the rigidity and add a monthly bill. Blank-sheet cloud design instead keeps the only copy of the truth in object storage and treats compute as disposable — many clusters, sized independently, killed when idle, all on the same data. It resists retrofitting because the old design assumes local disk everywhere.
Open-source commercialization. If the engine is free, the business must be something else: sell support (SLAs, patches, indemnity — the Red Hat model), or sell a hosted product — the engine plus the operations, security and UI you would otherwise build. Databricks took the second, and largely had to: the Apache Software Foundation governed Spark, not the company.
The stealth database company
Snowflake was founded on July 23, 2012 in San Mateo, California (Wikipedia dates it precisely; treat the exact day as reported rather than filed). The founding trio was unusually specialized even by database standards: Benoît Dageville and Thierry Cruanes, both former Oracle data architects who had worked on Oracle's core database kernel, plus Marcin Żukowski, who had done this once already: he co-founded Vectorwise, the analytical-database spinout of Amsterdam's CWI, invented vectorized query execution during his PhD there, and sold the company to Actian in 2010 before leaving in 2012.
Concept — what a database kernel engineer does. Most database work sits above the engine. Kernel work is below it: the optimizer that picks join order, the storage layer that sets physical layout, the transaction manager, the executor that turns a plan into CPU instructions. Oracle's kernel is one of the few places that happens at scale, and it teaches which parts of a warehouse are load-bearing.
Concept — vectorized execution. Classic engines push one row at a time through a chain of function calls: huge per-row overhead, CPU cache and SIMD units idle. Vectorized execution pushes batches of column values — thousands at a time — through tight loops, so the fixed cost amortizes. Żukowski's CWI work made that the standard shape of an analytical engine.
That is not a group that stumbles into a data warehouse; they had hit the previous generation's ceiling and knew which wall to knock down. Dageville's framing reads like a commit message: a deliberate decision to separate compute from storage, "fully and without compromise," which "eliminated resource contention as a limiting factor." The formal version arrived years later — the team's SIGMOD 2016 paper, The Snowflake Elastic Data Warehouse, describing the design set in 2012.
The commercial choices matched the technical one. Sutter Hill Ventures put in a reported $5M Series A in 2012, and Sutter Hill partner Mike Speiser served as first CEO from 2012 to 2014 — a VC in the operator's chair, holding the company quiet while the engine got built. Speiser is also widely credited with the name — reportedly a nod to the founders' shared love of skiing, though Dageville prefers the cloud wordplay ("Snow is pure. Each flake is different"). Stealth ran roughly two years, and when the company surfaced in October 2014 it did so with about 80 organizations already using the product and a $26M Series B led by Redpoint Ventures.
Concept — what stealth mode buys. Going dark costs early feedback, hiring signal and press. It buys the right to change your mind: interfaces nobody depends on yet can be torn up for free, and two years is roughly how long a from-scratch storage engine takes to stop being wrong.
General availability on AWS followed in mid-2015 — and here the record genuinely splits: SiliconANGLE reports GA on June 23, 2015, InfoQ's coverage a July 28, 2015 announcement. Month and year are solid; the exact day is not, so we won't pretend. The 2015 funding is murkier still — period reporting cites a $45M round from Altimeter, Redpoint, Sutter Hill and Wing, while other sources describe a $79M Series C led by Altimeter closing that June. Those figures have never been cleanly reconciled publicly, so treat them as disputed rather than picking the prettier one.
What shipped at GA is the more interesting artifact: data as compressed 16MB files on Amazon S3, pulled into EC2 compute clusters on demand, with zone maps and data skipping instead of traditional indexes. Read that spec sheet and the next decade of the business model is visible: if storage is S3 and compute is ephemeral, you cannot sell seats. You sell consumption.
The open-source project that grew a company
Databricks' origin has no stealth phase because there was nothing to hide: the crown jewel was public three years before the company existed.
Apache Spark started in 2009 as a UC Berkeley AMPLab project by grad student Matei Zaharia, built almost incidentally as a pilot workload for the Mesos cluster manager. It was open-sourced in 2010, the same year Spark: Cluster Computing with Working Sets landed at USENIX HotCloud, introducing RDDs and showing 10x speedups over Hadoop on iterative ML jobs. The sequel, Resilient Distributed Datasets, took USENIX Best Paper at NSDI 2012 with claims of up to 100x over prior multi-pass models.
By 2013 the project's traction had outrun what a research lab can responsibly support. Databricks was incorporated on June 10, 2013 by seven people from the AMPLab/Spark circle — Ali Ghodsi, Ion Stoica, Matei Zaharia, Patrick Wendell, Reynold Xin, Andy Konwinski, and Arsalan Tavakoli-Shiraji — explicitly to commercialize and professionally support Spark for enterprises that didn't have a team of PhD computer scientists on staff. Zaharia has said Stoica also wanted the startup so users would take the lab's research more seriously. That same month Spark entered the Apache Incubator; it graduated to a Top-Level Apache Project on February 27, 2014, by which point over 120 developers from 25 organizations had contributed.
Andreessen Horowitz led a reported $13.9M Series A in 2013 (some sources say September, others just "late 2013"), positioning the company as the alternative to MapReduce-style batch processing. The first commercial product, Databricks Cloud, was unveiled at Spark Summit 2014 with limited AWS availability that November, paired with a $33M Series B. Ion Stoica was founding CEO until January 11, 2016, when he moved to Executive Chairman and Ali Ghodsi — previously VP of Engineering and Product — took over. Stoica has said staying longer would have cost him his Berkeley faculty position; he chose the classroom.
Note the shape of that: Databricks did not open-source its engine as a growth tactic. The engine was already open, already governed by Apache, already worked on by 25 organizations, and the company's job was to work out what to sell given that. Every "we're the open one" message it has run since traces back to a lab decision in 2010.
The head-to-head
| Snowflake | Databricks | |
|---|---|---|
| Founded | July 23, 2012, San Mateo, CA (reported) | Incorporated June 10, 2013 (reported) |
| Founders | Benoît Dageville, Thierry Cruanes (ex-Oracle database-kernel architects), Marcin Żukowski (Vectorwise/CWI, vectorized execution) | Seven from UC Berkeley AMPLab: Ghodsi, Stoica, Zaharia, Wendell, Xin, Konwinski, Tavakoli-Shiraji |
| Origin | New company, blank sheet, ~2 years in stealth | Apache Spark, born 2009 at Berkeley; company built around existing OSS |
| Founding thesis | Total separation of storage and compute, cloud-native from scratch (SIGMOD 2016) | Commercialize + support Spark for enterprises without in-house PhD systems teams |
| Proof-of-concept artifact | The product itself; paper came later (2016) | The papers came first: HotCloud 2010, NSDI 2012 Best Paper |
| First product / GA | Elastic Data Warehouse, GA mid-2015, AWS only — 16MB files on S3, on-demand EC2 compute, zone maps not indexes | Databricks Cloud, unveiled Spark Summit 2014, limited AWS availability Nov 2014 |
| First institutional money | ~$5M Series A, Sutter Hill Ventures, 2012 (reported); $26M Series B, Redpoint, Oct 2014 | $13.9M Series A, Andreessen Horowitz, 2013 (reported); $33M Series B, 2014 |
| Code posture | Closed product, proprietary from day one | Apache Top-Level Project (Feb 2014), 120+ contributors from 25 orgs at graduation |
| CEO lineage | Mike Speiser (VC-as-CEO, 2012–2014) → Bob Muglia, ex-Microsoft (2014) → Frank Slootman, ex-ServiceNow (May 2019) | Ion Stoica, co-founder/professor (2013) → Ali Ghodsi, co-founder, ex-VP Eng/Product (Jan 11, 2016) |
| Emerging market motion | Stealth → surface with 80 live customers → hire an IPO-tested operator | Publish → grow a community → hire the CEO from inside the founding seven |
The CEO row is the tell. Snowflake's pattern is import an operator: a VC holds the seat during construction, a Microsoft executive takes it to enterprise scale, a serial IPO CEO takes it public. Databricks' is promote a founder: the professor hands the seat to the co-founder running engineering and stays on as Executive Chairman. One treats leadership as a hired capability, the other as continuous with the original research group — each is what its origin makes natural.
The two founding bets, and what each one costs
Closed, product-first (Snowflake). Pros — coherence, polish, control: one team owns storage format, optimizer and user experience at once, so the pieces genuinely fit; support and performance are yours to guarantee, not coordinate; nothing external depends on your internals, so you can change anything up to GA. Cons — trust, lock-in, ecosystem speed: buyers take the architecture on assertion, since nobody outside can read it (the design was not peer-reviewed until SIGMOD 2016); every internal decision becomes lock-in accepted on faith; integrations arrive only as fast as you build them.
Open, project-first (Databricks). Pros — adoption, community, hiring: the flywheel spins before you sell anything (two well-cited papers, a Best Paper award, 120+ contributors from 25 organizations by Spark's February 2014 Apache graduation); those contributors harden the engine at no cost to you; recruiting is easy when your best users are in the commit log. Cons — monetization gap, support burden, free-riding: you must invent a business doing what the free thing does not, which is why the first product came a year after incorporation; you carry users who pay nothing; and since governance sits with the foundation, a rival can run your engine commercially for free.
What to Learn From This
- Read the substrate, not the roadmap. Both strategies fell out of one fact about cheap, elastic object storage. When the substrate shifts, architecture is settled before product is.
- Storage/compute separation is a pricing model, not just a design. Ephemeral compute kills seat pricing and makes consumption pricing inevitable — your architecture is already choosing your invoice.
- Pedigree predicts blind spots as reliably as strengths. Kernel veterans build superb engines and closed ones; researchers build superb abstractions and monetize late.
- "Open" is a governance question, not a marketing one. Databricks never owned Spark; the ASF did. Check who holds the trademark, the commit bit and the release vote.
- Pick stealth or open by your cost of being wrong. Cheap to fix? Learn in public. Baked into a storage format customer data will live in? Stay dark until it holds.
Scorecard
Round 1: DRAW. Both teams read the same 2012 cloud moment correctly and executed opposite plays flawlessly. Snowflake's route — closed, stealth, kernel veterans, ship only when storage/compute separation actually worked — produced a product with 80 live customers before anyone outside knew the company existed, and a design its own authors were still describing, unchanged from 2012, in a 2016 SIGMOD paper. Databricks' route — publish first, win a Best Paper, let 120 contributors from 25 organizations harden the engine inside Apache, then sell the managed experience — produced a Top-Level Apache Project and a commercial platform in the same window on a fraction of the capital. You cannot score a stealth product company against an open-source community company on either's home metric without cheating. Both were right, at the same time, in incompatible ways — which is exactly why the next decade got so loud.
Running tally: Databricks 0 — Snowflake 0 (1 draw)
Tomorrow
Part 2 takes the two founding theses into the architecture that grew from them: warehouse versus lakehouse, and why each side thinks the other is solving the easy half.
Sources
- Snowflake Inc. — Wikipedia (founding, founders, stealth exit, early funding)
- Snowflake Raises $26M in Funding to Reinvent the Data Warehouse — GlobeNewswire, Oct 2014
- Snowflake launches its cloud-based data warehouse into general availability — SiliconANGLE, June 23, 2015
- Snowflake Cloud Data Warehouse — InfoQ, July 2015 (16MB files on S3, zone maps)
- The Snowflake Elastic Data Warehouse — ACM SIGMOD 2016
- Spark: Cluster Computing with Working Sets — USENIX HotCloud 2010
- Resilient Distributed Datasets — USENIX NSDI 2012 (Best Paper)
- The Apache Software Foundation Announces Apache Spark as a Top-Level Project, Feb 2014
- Databricks — Founders
- Databricks announces changes to leadership team (Stoica → Ghodsi, Jan 2016) — BigDATAwire
Top comments (0)