Question 1

What is NoSQL?

Accepted Answer

NoSQL is a loosely defined family of mostly open-source, non-relational databases that emerged in the early 2010s, largely to run well on clusters of commodity machines. There is no single authoritative definition. Common traits include rejecting the relational model, scaling horizontally, and operating without a fixed schema. The most important outcome of the movement is polyglot persistence: treating the relational database as one option among several rather than the automatic default.

Question 2

What are the four main types of NoSQL databases?

Accepted Answer

The four widely recognized families are key-value, document, column-family, and graph. The first three are aggregate-oriented: they store and retrieve data as aggregates keyed by an ID. Key-value stores treat the value as an opaque blob; document stores can see inside the value and query it; column-family stores group columns into families within a row. Graph databases are different: they store small records with rich, traversable relationships and are not aggregate-oriented.

Question 3

What is an aggregate in NoSQL data modeling?

Accepted Answer

An aggregate is a collection of related data treated as a single unit, such as an order with its line items, address, and payment. The idea comes from Domain-Driven Design. Aggregates are central to NoSQL because they form a natural unit of distribution on a cluster, keeping data that is used together on one node, and they act as the atomic unit for updates, giving limited but useful transactional control within a single aggregate.

Question 4

What does the CAP theorem actually say?

Accepted Answer

The CAP theorem states that among Consistency, Availability, and Partition tolerance, you can fully guarantee only two. Since real clusters can always experience network partitions, the practical meaning is that during a partition you must trade off consistency against availability. It is not binary; you can sacrifice a little consistency for more availability. CAP defines availability narrowly: every request to a non-failing node must return a response.

Question 5

What is eventual consistency?

Accepted Answer

Eventual consistency is the guarantee that, if no new updates are made, all replicas of a data item will converge to the same value over time. With replication, an update may reach one replica before another, so different readers can briefly see different values. Data that is behind is called stale. Eventual consistency trades immediate replica agreement for higher availability and lower latency, which many domains tolerate.

Question 6

What is the difference between sharding and replication?

Accepted Answer

Sharding and replication are orthogonal distribution strategies. Sharding puts different data on different nodes, so each node owns a subset; it scales both reads and writes but does not improve resilience on its own. Replication copies the same data to multiple nodes, improving read scalability and fault tolerance but doing little for writes and introducing inconsistency risk. Production systems often combine both, commonly with a replication factor of three.

Question 7

What is the quorum formula R + W > N?

Accepted Answer

In a replicated system, N is the replication factor (copies of an item), W is the number of nodes that must confirm a write, and R is the number contacted per read. When R + W is greater than N, the read set and the latest write set must overlap on at least one node, guaranteeing a strongly consistent read. A write quorum needs W greater than N/2 so two conflicting writes cannot both succeed. Tuning R and W trades consistency, latency, and availability.

Question 8

When should you use a key-value store?

Accepted Answer

Key-value stores fit data accessed by a single key as a self-contained blob: web session data keyed by session ID (often with a time-to-live), user profiles and preferences, and shopping carts keyed by user ID. They offer great performance and easy scaling. Avoid them when you need relationships between data, multi-key transactions, queries based on the contents of the value, or operations across many keys at once.

Question 9

When should you use a document database?

Accepted Answer

Document databases suit flexible, self-describing data you also need to query by content: event logging, content management and blogging platforms, real-time analytics, and e-commerce catalogs and orders. Unlike key-value stores, they can query fields inside documents and index on them. Avoid them when you need atomic operations spanning multiple documents, or ad-hoc queries against an aggregate structure that keeps changing shape.

Question 10

When should you use a graph database?

Accepted Answer

Graph databases excel when value comes from connections: social networks and other link-rich domains, routing and location-based services, and recommendation engines. They persist relationships as first-class entities, making traversals far cheaper than relational joins for highly connected data. They are usually ACID and single-server. Avoid them for bulk updates across all nodes or for global operations on datasets too large to fit or replicate.

Question 11

What is polyglot persistence?

Accepted Answer

Polyglot persistence means using different storage technologies for different needs instead of forcing every requirement into one engine. An e-commerce app might keep sessions and carts in a key-value store, orders in a relational database, the catalog in a document store, and recommendations in a graph database. It can apply within one application or across an enterprise, and it adds programming and operational complexity that must be weighed against the benefit of a good fit.

Question 12

Are NoSQL databases really schemaless?

Accepted Answer

Not entirely. Schemaless means the database does not enforce structure, so you can add fields freely and store nonuniform records without nulls. But the schema does not vanish; it moves into the application code, which still assumes specific field names, meanings, and types. This implicit schema means you must read the code to understand the data, the database cannot validate or optimize on structure, and migrations still require care.

Question 13

What is map-reduce and why does it suit clusters?

Accepted Answer

Map-reduce organizes computation to parallelize across a cluster while keeping processing near the data. The map function reads one aggregate at a time and emits key-value pairs, running in parallel on the node holding the data. The reduce function takes all values for a key and combines them. Partitioning runs reducers in parallel by key, and a combiner pre-aggregates locally to cut network traffic. Results can be saved as materialized views.

Question 14

What are version stamps used for?

Accepted Answer

A version stamp is a field that changes whenever a record changes, used to detect concurrent modifications. You note the stamp on read and verify it has not changed on write, implementing optimistic concurrency. Stamps can be counters, GUIDs, content hashes, timestamps, or combinations. On peer-to-peer systems a vector stamp, a set of per-node counters, can tell which version is newer or detect a write-write conflict when neither descends from the other.

Question 15

Should you choose NoSQL or stick with a relational database?

Accepted Answer

Most applications are still better served by a relational database, which is mature, well understood, and rich in tooling. Choose NoSQL only when you can show a real advantage in programmer productivity (a model matching your data) or data-access performance (volume, scaling, latency, throughput). Evaluate by building and measuring real features, including bad-fit cases, rather than trusting vendor claims. Encapsulating storage behind services helps hedge an uncertain choice.

Why NoSQL and Aggregate Data Models(7 questions)

Why did relational databases become the default for serious data storage, and what core benefits do they provide?

What is the object-relational impedance mismatch?

What is the difference between an integration database and an application database, and why does it matter for NoSQL?

Why were clusters the decisive driver behind NoSQL, and why do relational databases struggle on them?

What is an aggregate in aggregate-oriented data modeling, and why is it useful on a cluster?

What does it mean for a database to be 'aggregate-ignorant', and what is the trade-off?

How do aggregate boundaries affect transactions and atomicity in aggregate-oriented databases?

Relationships, Graphs, and Schemaless Modeling(5 questions)

How do aggregate-oriented databases handle relationships between separate aggregates?

What is a graph database, and what kind of data is it best suited for?

Why are graph traversals fast compared with relational joins for highly connected data?

What does 'schemaless' really mean in NoSQL, and why is there still an implicit schema?

What are materialized views in a NoSQL context, and when do you use eager versus batch updates?

Distribution Models(6 questions)

What is the difference between sharding and replication?

Why is a single-server distribution model often the best choice, even for a NoSQL database?

What is sharding, and what factors make for a good distribution of data across shards?

How does master-slave replication work, and what are its benefits and limits?

How does peer-to-peer replication differ from master-slave, and what new problem does it create?

How are sharding and replication combined in practice, and what is a typical replication factor?

Consistency and the CAP Theorem(7 questions)

What is a write-write conflict, and how do pessimistic and optimistic approaches handle it?

What is a read-write conflict (logical consistency), and what is the inconsistency window?

What is replication consistency and eventual consistency, and how do read-your-writes and session consistency help?

State the CAP theorem. Why is its definition of 'availability' special?

In practice, how should you think about the CAP trade-off, and why is consistency-versus-latency often the better framing?

What does it mean to relax durability, and when is that a reasonable trade-off?

How do quorums work, and what does the inequality R + W > N guarantee?

Version Stamps(3 questions)

What problem do version stamps solve, and how do business and system transactions relate to them?

What are the common ways to construct a version stamp, and what are their trade-offs?

How do vector stamps detect conflicts across multiple peer nodes?

Map-Reduce(4 questions)

What is the basic map-reduce pattern, and why does it suit clusters?

What are partitioning and combining in map-reduce, and what makes a reducer 'combinable'?

How do you compose multi-stage map-reduce calculations, and why can't you simply average partial results?

What is incremental map-reduce, and how does it relate to materialized views?

NoSQL Database Families(9 questions)

What is a key-value store, and what are its query characteristics?

What are good use cases for a key-value store, and when should you avoid one?

What is a document database, and how does it differ from a key-value store?

What query, consistency, and scaling features do document databases typically offer, and what are their use cases?

When should you avoid a document database?

What is a column-family store, and how is its data model best understood?

What are good use cases for column-family stores, and when should you avoid them?

What features distinguish graph databases, and why is scaling them hard?

What are the strongest use cases for graph databases?

Schema Migration(3 questions)

How are schema migrations managed in a strong-schema relational database?

How do you migrate data in a schemaless store, and what is incremental migration?

What special challenges arise when migrating graph databases or changing aggregate structure?

Polyglot Persistence and Choosing a Database(5 questions)

What is polyglot persistence, and why is it the central idea behind the NoSQL movement?

Why prefer wrapping data stores in services over letting applications hit them directly?

What are the two main reasons to choose a NoSQL database, and how should you evaluate the choice?

When should you stick with a relational database, and how can you hedge an uncertain choice?

What is event sourcing, and what capabilities does it unlock?