Specialized Data Stores: Columnar, Time-Series, Blob & Search
A handful of workloads don't fit relational, key-value, or document databases well — and are common enough to deserve purpose-built stores.
Intermediate
TopNotchNote
Notes that matter
beyond relational, key-value, and document
SQL vs. NoSQL and Key-Value Stores cover the databases most services touch every day. A handful of workloads don't fit any of those well, and are common enough in real systems to be worth naming individually: columnar analytics stores, time-series databases, search-oriented stores, and blob storage.
columnar databases
A relational database stores data row by row on disk — reading one order means reading one contiguous chunk with every column of that order. A columnar database stores data column by column instead: every restaurant's rating, across every row, is stored contiguously.
This inverts which queries are cheap. "Fetch order 482, every field" (a row-shaped query) is now more expensive, since values are scattered across many column files. But "what's the average order total across 50 million orders" (a column-shaped, analytical query) becomes dramatically cheaper, because the engine only has to scan the one column it needs instead of every row's full width. Examples: Amazon Redshift, ClickHouse, BigQuery, DuckDB. Good fit: analytics, reporting, large-scale aggregation.
Not the same thing as a wide-column store. Cassandra and HBase are often filed under "columnar", but they store data row-wise within a partition — a row key holds many columns together. That makes them excellent at "fetch everything for this key" at enormous scale, and poor at exactly the full-column analytical scan described above. If the workload is "average one attribute across 50 million rows", you want a true columnar engine; if it's "read this user's event history, fast, at any scale", you want a wide-column store.
time-series databases
A time-series database is optimized for data that's written once, in roughly chronological order, and rarely updated afterward — a driver's GPS ping every few seconds, a server's CPU usage every minute. Two properties define the workload: writes are append-only and arrive in near time-order, and reads are usually bulk range scans ("show CPU usage for the last 24 hours") rather than random single-record lookups.
Storing this kind of data in a general-purpose relational database works but wastes its strengths (random-access indexing, complex joins) on a workload that doesn't need them. Purpose-built time-series databases like InfluxDB or TimescaleDB compress sequential numeric data far more efficiently and serve range scans much faster. This is exactly the data shape behind monitoring and observability systems and distributed logging.
blob storage
Not every large object belongs in a database at all. A restaurant's cover photo or a delivered-order proof-of-delivery photo is exactly the kind of unstructured binary content that blob storage (Binary Large Object storage — think Amazon S3) is designed for: store the raw bytes cheaply and durably, hand back a URL, and let a CDN handle fast delivery to end users.
The pattern that shows up constantly: the database stores a reference to the blob (a URL or object key), never the blob itself. A
restaurants row has a cover_photo_url column pointing at blob storage, not a multi-megabyte binary column — keeping the database itself small, fast, and easy to back up.search-oriented stores
None of the databases above are good at full-text or fuzzy search — "find restaurants matching 'sushi'" tolerating typos and ranking by relevance. That's purpose-built territory for stores like Elasticsearch, covered fully in Distributed Search. The common pattern is to keep the primary database as the source of truth and stream data into a search index asynchronously, rather than treating the search engine itself as durable primary storage.
picking per workload, not per system
The recurring theme across this Data Layer group: large real systems don't pick one database for everything. PlateRoute might keep orders in a relational database, sessions in a key-value store, the catalog in a document store, driver location history in a time-series database, and photos in blob storage behind a CDN — each choice driven by that specific workload's read/write pattern, not by a single company-wide database standard.