Characteristics of NoSQL: Scalability, Consistency and a Worked Sharding Example

Learn NoSQL characteristics through flexible quiz records, model choices, exact sharding and storage calculations, quorum overlap, and a network partition.

KnowledgeGate Team

Exam prep & CS education

Updated 13 Nov 20266 min read
Characteristics of NoSQL: Scalability, Consistency and a Worked Sharding Example

NoSQL is often compressed into slogans such as "schema-less", "no joins" and "eventually consistent". None is universal or precise enough to guide a design choice. A single quiz-attempt workload illustrates the distinction between common characteristics and product-dependent behaviour through flexible documents, three shards, three replicas and a network partition.

NoSQL meaning: an umbrella, not one database design

NoSQL is an umbrella for non-relational database families, often expanded as "not only SQL" in teaching material. It does not name one standard, storage format or query language. It also does not prove that a system rejects SQL-like queries.

Four important families are key-value, document, wide-column and graph databases. Their modelling units differ. A relational design may put students, quizzes and attempts in separate tables connected by keys. A document design may store one attempt as a self-contained aggregate. SQL Queries and Joins in DBMS explains the relational side; joins are useful, not a defect.

Use access patterns, integrity needs, relationships, scale and operational constraints to choose a model. The word "modern" proves nothing. The CS Fundamentals category provides the broader learning route for these database foundations.

Characteristics commonly associated with NoSQL

NoSQL characteristics are tendencies, not promises made by the label.

Characteristic

Common tendency, not guarantee

Trade-off

Flexible records

Records may have optional fields

Application validation work

Aggregate modelling

Related data may be one unit

Copied updates can fan out

Horizontal partitioning

Records may be divided by key

Poor keys create imbalance

Replication

Copies may survive node failure

Storage and coordination cost

Distributed availability

Multiple nodes may answer

Failure behaviour needs rules

Consistency choices

Read and write rules may be configurable

Older or conflicting values

Model-specific queries

Storage may match key, row or traversal access

Harder ad hoc queries

Consider two exact documents: A17={student_id:101, exam:"DBMS-1", score:8, tags:["nosql","dbms"], device:"Android"} and A18={student_id:102, exam:"DBMS-1", score:7, tags:["nosql"], proctor_flags:["tab-switch"]}. Their optional fields differ, but an application or database may still require integer score from 0 to 10. Flexible schema is not schema-free.

Model and deployment are separate. A document database can use one node; a relational system can partition and replicate. Distribution and tunable consistency are prominent NoSQL themes, but the label establishes neither topology nor behaviour.

Match the NoSQL family to the access pattern

Use the question being asked to select a model:

  • Key-value: session:101 -> {state:"active", ttl_seconds:1800} suits lookup by a known key.

  • Document: attempt:A17 -> the complete A17 record suits retrieving one attempt as an aggregate.

  • Wide-column: row key student_id=101 with attempt#A17:score=8 and attempt#A21:score=9 supports a student-centred attempt list.

  • Graph: (Student:101)-[:ATTEMPTED]->(Quiz:"DBMS-1") and (Student:101)-[:FOLLOWS]->(Student:104) support relationship traversal, such as finding quizzes attempted by followed students.

No family is universally faster, and one application need not use only one model. Family choice answers how data is accessed; sharding, replication and quorum rules answer how a deployment scales and behaves under failure.

Worked example: partition 600,000 attempts and calculate replication cost

Suppose 600,000 attempt documents arrive daily and each averages 2 KB. Using decimal units:

600,000 x 2 KB = 1,200,000 KB = 1,200 MB = 1.2 GB

That is the logical daily data volume. Now divide records across three logical shards using the classroom function shard = student_id mod 3:

  • 101 mod 3 = 2 and 104 mod 3 = 2, so 101 and 104 go to shard 2.

  • 102 mod 3 = 0 and 105 mod 3 = 0, so 102 and 105 go to shard 0.

  • 103 mod 3 = 1 and 106 mod 3 = 1, so 103 and 106 go to shard 1.

These IDs split evenly, although real balance depends on the key distribution. Assuming uniform traffic, each shard receives 600,000 / 3 = 200,000 documents and 1.2 GB / 3 = 0.4 GB, about 400 MB, daily.

At replication factor N=3, copies use 1.2 GB x 3 = 3.6 GB daily before indexes, metadata, compression and backups. Nodes distribute data; they do not shrink it.

Set W=2 and R=2. Since W+R=4>N=3, the read and preceding write sets overlap in this simplified quorum model. Student 104's A24 routes to shard 2. Replicas S2-A and S2-B acknowledge score:8 -> 9; S2-C is delayed. One unavailable replica leaves two acknowledgements, but one available replica cannot satisfy either setting. Overlap does not unconditionally guarantee the newest value because versions, failed writes and conflict rules still matter.

Six attempt documents routed by student_id mod 3 into three shards, with shard 2 expanded into replicas S2-A, S2-B and S2-C.

Consistency and CAP during one network partition

Initially, every replica stores A24 as score=8, version=11. A network partition isolates S2-A from the majority pair S2-B + S2-C.

In the CP branch, B and C accept score=9, version=12. A refuses or delays the operation because it cannot reach the required quorum. The system preserves one accepted order, but a client that can reach only A cannot complete the operation.

The earlier W=2 rule cannot accept a write on A alone. The contrasting AP branch instead uses a local-accept policy, so isolated A accepts score=10 at the classroom timestamp 10:02, while B and C accept score=9 at 10:01. Both sides answer during the partition and temporarily disagree. After repair, an explicit classroom last-write-wins rule keeps 10 and discards 9. Real clock skew and lost intent make this risky, so systems may instead use version metadata, mergeable data types or application reconciliation.

CAP consistency is linearizable behaviour: completed operations appear in one global order, and a read does not return a value older than the latest completed write. It is not the "C" in ACID. The consistency-versus-availability choice becomes unavoidable during a network partition, so "pick any two forever" is too crude. Eventual consistency means replicas can converge if updates stop and reconciliation succeeds. It does not mean that every NoSQL read is stale.

Attempt A24 on replicas S2-A, S2-B and S2-C during a network partition, with the CP branch beside the AP branch.

Schema, denormalisation and transactions are not absolute rules

NoSQL does not mean no validation, no indexes, no transactions or no query language. Capabilities and guarantees depend on the database, operation scope, configuration and failure state.

Suppose quiz_title="NoSQL Basics" is copied into all 600,000 daily attempt documents. An attempt view can display it without another lookup, but changing the title to NoSQL Characteristics may require updating as many as 600,000 copied documents for that day. A referenced quiz record needs one title update, but reading an attempt may require another lookup or server-side join capability. The read and write pattern decides which cost is acceptable.

Transactions and Concurrency Control in DBMS develops ACID and schedule reasoning further. That is distinct from replica consistency and partition behaviour.

How questions test NoSQL characteristics, and traps to avoid

Typical questions ask you to choose a model, distinguish flexibility from absent validation, compute a partition and storage, reason from N, R and W, classify CP or AP behaviour, or compare denormalisation with references.

Use these answer-first checks:

  • 104 mod 3 = 2, so student 104 routes to shard 2.

  • Logical daily volume is about 1.2 GB; replication factor 3 produces about 3.6 GB before overhead.

  • R+W=4>3 creates quorum overlap in the stated model.

  • Refusing the isolated A-side write is the CP branch; accepting conflicting values 10 and 9 is the AP branch.

  • Different optional fields in A17 and A18 demonstrate structural flexibility, not absence of rules.

NoSQL is not automatically faster. "Schema-less" is not "structure-less". The label does not guarantee horizontal scale. Replication is not backup. CAP consistency is not ACID consistency. Eventual consistency is not permanent inconsistency, and denormalisation is not random duplication.

NoSQL characteristics: one final design check

Choose the data model from the access path. Validate flexible records, partition to distribute load, replicate for fault tolerance, and state consistency and conflict rules. Remap IDs 101 to 106, recompute 1.2 GB and 3.6 GB, then explain the A24 CP and AP branches aloud.

Use Zero to Hero for a broad CS learning path, or Computer Science Fundamentals for Placements for placement-focused revision.