Database Options // Reference

A full SQL relational engine in a single ~1 MB library, storing the whole database in one portable file. The most deployed database on earth — it is inside every phone, browser, and OS. Transactional (ACID), no daemon, no config, no network.

"SQLite for analytics." Same embedded, single-file, no-server model, but stored column-wise with a vectorized engine. Queries CSV, JSON, Parquet, and remote S3 files directly in place, with no import step, and joins them against its own tables.

The original embedded key-value store (1991, now Oracle). Byte-string key to byte-string value, with B-tree, hash, and queue access methods, transactions and replication. Still buried in mail servers, LDAP directories, and package managers.

A memory-mapped B+tree key-value store in about 10k lines of C. Readers never block and never lock; the OS page cache does the caching. Copy-on-write means it cannot corrupt on crash.

Log-structured merge-tree (LSM) key-value engines from Facebook and Google. Writes land in memory and are flushed in sorted batches, so ingest is very fast. Rarely used directly — they are the storage layer inside Kafka Streams, TiDB, and many others.

Embedded, file-based vector database on the Lance columnar format. Same "just a directory of files" model as SQLite/DuckDB but tuned for embeddings plus metadata, with versioning and local or S3 storage.

Embedded SQL databases written in Java, running inside the JVM process. Their real job is testing: stand up a database in a unit test with no external service.

Pure-Go embedded key-value stores. Bolt (and its maintained fork bbolt) is a memory-mapped B+tree in the LMDB tradition; Badger is the LSM alternative for write-heavy work. Both compile straight into a Go binary with no CGO.

Mobile-first embedded databases that store language objects directly instead of rows, skipping the object-relational mapping step. Realm (now MongoDB Atlas Device SDK) adds device-to-cloud sync.

SQLite reimagined for the network age. libSQL is an open fork adding replication and a server mode; Turso and Cloudflare D1 host it at the edge so each region reads from a local replica.

The most capable open-source relational database, and the correct default for almost any server-side application. Full ACID, rich SQL, and an extension system that lets it also do geospatial (PostGIS), time-series (TimescaleDB), vectors (pgvector), graph (Apache AGE), and full-text search without a second product.

The other giant of open-source SQL, and the engine behind most of the classic web stack. Simple replication, huge hosting support. MariaDB is the community fork, kept free of Oracle's dual-licensing.

Microsoft's enterprise relational database. Superb tooling, a mature optimizer, and first-class integration with .NET, Active Directory, Power BI, and Azure.

The high end of enterprise relational: extreme reliability features, RAC clustering, partitioning, and the deepest optimizer in the business. Also the most expensive and the most audited license in software.

Descendant of Borland InterBase. Small, embeddable or server-mode, ACID, with a single-file database. A quieter middle ground between SQLite and Postgres.

Database and application builder in one: tables, forms, reports, and a GUI, aimed at non-programmers. Access uses the Jet/ACE engine in an .accdb file; FileMaker is the cross-platform equivalent.

Postgres-wire-compatible SQL that shards and replicates itself automatically across nodes and regions, with serializable transactions. Designed to survive machine, rack, and region failure without operator action.

Distributed SQL that reuses the actual PostgreSQL query layer on top of a sharded, replicated storage engine, so compatibility is closer than most rivals. Also offers a Cassandra-style API.

MySQL-compatible distributed SQL with a companion columnar store (TiFlash), so the same cluster serves transactions and analytics — "HTAP" — without a separate pipeline.

The system that created this category: globally distributed, externally consistent SQL using atomic-clock-backed timestamps. Fully managed only.

A sharding and connection-pooling layer in front of real MySQL servers, built at YouTube. Applications see one MySQL; Vitess routes queries to the right shard. PlanetScale is the managed version, with branching workflows for schema changes.

The fastest widely-available open-source analytical database. Ingests millions of rows per second and answers aggregate queries over billions of rows in well under a second. Powers most "real-time analytics" products you have used.

Columnar store designed for streaming ingest and sub-second slice-and-dice over time-partitioned event data, with high query concurrency.

Built at LinkedIn for user-facing analytics at millisecond latency — the engine behind "who viewed your profile" style features.

Not a database — a distributed SQL engine that queries data where it already lives: S3 files, Postgres, Kafka, MongoDB, and more, joining across them in one query.

The research pioneer of column-store databases and the ancestor of much of what DuckDB and ClickHouse do today. Still solid for academic and mid-size analytics.

MySQL-protocol columnar engines aimed squarely at ClickHouse, but with genuinely good join performance — so you can keep a normalized star schema instead of denormalizing everything.

MySQL-compatible database holding both rowstore and columnstore tables, so one system serves transactions and analytics on live data.

The previous generation of on-premise massively-parallel warehouses. Greenplum is Postgres-derived and open source; Vertica and Exasol are commercial and very fast.

The reference cloud warehouse: independent compute "warehouses" over shared storage, so teams do not contend, plus zero-copy cloning and time travel.

Serverless warehouse with no cluster concept at all — submit SQL, pay for bytes scanned or reserved slots. Excellent for petabyte-scale ad-hoc work and GA4 data.

AWS's warehouse, Postgres-derived, now with a serverless mode and Spectrum for querying S3 directly.

Spark-based lakehouse: analytics and machine learning over open table formats in object storage, with a SQL warehouse layer on top.

In-memory data-structure server: strings, hashes, lists, sets, sorted sets, streams, HyperLogLogs, geo indexes, pub/sub. Sub-millisecond, with optional disk persistence. Valkey is the Linux Foundation fork created after Redis changed license.

A pure multi-threaded memory cache. No data structures, no persistence, no clustering — just key to blob, and it never pretends otherwise.

Fully managed key-value and document store with single-digit-millisecond latency at any scale, priced per request. You design the table around your access patterns before you write a line of code.

Strongly consistent (Raft) key-value stores for configuration, service discovery, leader election, and distributed locks. etcd is what Kubernetes stores its state in.

Masterless, eventually-consistent distributed key-value store modeled on Amazon's Dynamo paper. Prioritizes staying writable during network partitions.

Key-value store engineered around NVMe SSDs: indexes in RAM, data on flash, so it delivers sub-millisecond latency at RAM-like speed for a fraction of the cost.

Apple's distributed, strictly serializable ordered key-value store. Deliberately minimal — it provides transactions and durability, and you build the data model on top. Famous for its deterministic simulation testing.

Distributed in-memory grids that spread a dataset across a cluster's RAM and run computation next to the data, with SQL and compute-grid APIs on top.

In-memory database with a built-in Lua application server, so stored procedures are real code running beside the data. Write-ahead logging makes it durable.

The dominant document database. Stores BSON documents in collections, with secondary indexes, an aggregation pipeline, sharding, and (since v4) multi-document transactions.

Document store whose defining feature is multi-master replication with automatic conflict flagging — including to PouchDB in a browser or on a phone.

Managed document DB with real-time listeners and client-side SDKs, so browsers and phones talk to it directly under declarative security rules.

Not a separate product — a reminder. Postgres stores and indexes JSON documents (GIN indexes, path operators, jsonb_path_query) inside a relational database, so structured and unstructured data live in one transaction.

Document database with a memory-first architecture — it began life as Memcached — plus a SQL-like query language (SQL++/N1QL), full-text search, and mobile sync.

.NET-native document database with fully ACID multi-document transactions — unusual in this category — and automatic index creation from the queries you run.

Microsoft's globally distributed managed database, exposing document, wide-column, graph, and key-value APIs over one engine, with five explicitly selectable consistency levels and latency SLAs.

Masterless distributed database where every node accepts writes and data is replicated by a hash ring. Tunable consistency per query. Designed so that losing machines does not cause an outage.

A C++ rewrite of Cassandra with a shard-per-core architecture. Same data model and drivers, dramatically better latency and hardware efficiency.

The open-source BigTable clone, running on HDFS. Strongly consistent per row, with fast random access on top of a Hadoop data lake.

The original wide-column store, offered as a managed service. Single-digit millisecond reads at petabyte scale, with the HBase API.

The leading property-graph database, queried with Cypher. Stores pointers between nodes directly, so traversal cost depends on how many hops you take, not on how big the database is.

In-memory, Cypher-compatible graph database aimed at streaming graph workloads and real-time analysis.

One engine offering document, graph, and key-value models with a single query language (AQL), so you can join documents and traverse edges in one statement.

A Postgres extension adding openCypher graph queries to tables you already have, so graph and relational data share one transaction and one backup.

Managed graph database supporting both property graphs (Gremlin, openCypher) and RDF triples (SPARQL) on the same storage layer.

Graph databases built to scale past one machine. JanusGraph layers Gremlin over Cassandra or HBase; TigerGraph is a commercial parallel engine for deep-link analytics; Dgraph is a distributed native graph with a GraphQL-style language.

Store data as subject-predicate-object triples following W3C standards (RDF, OWL, SPARQL) and can infer new facts from ontologies. This is the technology behind linked open data and Wikidata.

Postgres extension that auto-partitions tables by time ("hypertables") and adds columnar compression, continuous aggregates, and retention policies — while keeping full SQL, joins, and every Postgres tool you already use.

The best-known dedicated time-series database, with its own line-protocol ingest and a full stack for collection, dashboards, and alerting.

The standard for infrastructure monitoring. Pulls metrics from HTTP endpoints, stores them locally, and queries with PromQL. Alerting is built in.

Prometheus-compatible metrics database designed for far better compression, high cardinality tolerance, and long retention, as a drop-in remote-write target.

Column-store time-series database with SQL plus time-specific extensions like SAMPLE BY and ASOF JOIN, aimed at financial tick data.

The column-store used across investment banks for tick data, with its own terse array language, q. Decades old and still the speed benchmark for time-series analytics.

Systems that sit behind Prometheus to give it what it deliberately lacks: unlimited retention in object storage, global query across clusters, and multi-tenancy.

The pre-Prometheus metrics standard: dotted metric names pushed via StatsD into fixed-size Whisper files that downsample automatically as data ages.

Distributed Lucene-based search and analytics engine. Handles full-text search, log analytics, aggregations, geospatial queries, and vector search in one cluster.

AWS's fork of Elasticsearch 7.10, kept fully Apache-licensed, with its own dashboards and security plugins.

Instant-search engine focused on typo tolerance and sane defaults. Single binary, configured in minutes, tuned for search-as-you-type.

Open-source, typo-tolerant instant search built as an Algolia alternative, with built-in clustering and hybrid keyword-plus-vector search.

Built-in tsvector indexing with stemming, ranking, and trigram fuzzy matching via pg_trgm. Not as strong as Lucene, but there is nothing to deploy and nothing to keep in sync.

The other major Lucene search server, and the older one. Configuration-driven rather than API-driven, with very strong faceting and enterprise document handling.

Lightweight C++ search engines that speak the MySQL protocol, so you query the index with SQL. Manticore is the maintained continuation of Sphinx.

Yahoo's serving engine: full-text, vector search, structured filters, and machine-learned ranking models evaluated inside the engine at query time, all on live updatable data.

Hosted instant-search API with excellent client libraries and analytics. The benchmark for search-as-you-type user experience.

Adds a vector column type plus HNSW and IVFFlat indexes to Postgres, so embeddings live in the same table and same transaction as the rows they describe.

Rust vector database with strong filtered search — payload conditions applied during the ANN traversal rather than after it, which is where naive systems lose results.

Distributed vector database aimed at billion-scale collections, with GPU indexing and separated storage and compute.

Developer-first vector store that runs embedded in a Python process or as a small server. The usual starting point for LLM prototypes.

Vector database with built-in embedding modules and hybrid keyword-plus-vector search, so it can generate embeddings for you at ingest time.

Meta's similarity-search library — not a database. Indexes live in memory in your process; persistence, filtering, and updates are your problem.

The best-known managed vector database. Serverless indexes, no tuning, and it handles sharding and replication for you.

The standard columnar file format. Column-wise storage with per-column compression and statistics, so engines skip whole blocks they do not need.

A standard in-memory columnar layout, so pandas, Polars, DuckDB, Spark, and R can hand data to each other with no serialization cost.

Adds database semantics to a pile of Parquet files in object storage: ACID commits, schema evolution, hidden partitioning, and time travel. The emerging open standard for lakehouses.

Databricks' equivalent of Iceberg: a transaction log over Parquet giving ACID, upserts (MERGE), and time travel.

DuckDB's lakehouse format that keeps the metadata in an ordinary SQL database instead of a tree of manifest files — simpler than Iceberg, with Parquet still holding the data.

The third open table format, built at Uber around incremental upserts and change-data-capture into a data lake.

ORC is the columnar format from the Hive world — similar in role to Parquet. Avro is row-oriented with a schema attached, the standard for Kafka messages and streaming records.

Not a database — a durable, replayable, ordered log. Producers append, many consumers read at their own pace, and messages persist for a configured retention. The backbone that connects most of the systems on this page.

Streaming databases that keep SQL materialized views incrementally up to date as new events arrive. You write ordinary SQL; the result is always current, with no scheduled refresh.

Purpose-built for event sourcing: the append-only stream of events is the data, and current state is a projection of it. Nothing is ever updated in place.

Append-only databases with cryptographic verification: every record is hashed into a Merkle tree, so tampering with history is mathematically detectable.

"Git for data." A MySQL-compatible database where you commit, branch, diff, and merge the actual table contents, with full history preserved.

Stores immutable facts as entity-attribute-value-time tuples, so the database is an accumulating record. Queries can run "as of" any past moment, and reads happen in the application process rather than on a server.

Newer multi-model database combining documents, graph relations, and SQL-like queries, with live queries and permissions designed for direct browser access.