Group 7: NoSQL / Multi-Model

Non-relational and multi-model stores targeting global distribution, low latency, flexible schema, caching, or key-value patterns. Azure primary options: Cosmos DB, Table Storage, Azure Cache for Redis, Managed Cassandra (Cosmos API / self-managed). Multi-API needs and globally distributed writes drive Cosmos DB. Pure ephemeral hot-path optimization pushes toward Redis. Extreme simplicity & cost map to Table Storage. Wide-column workloads with existing open-source ecosystems may lean to Cassandra.

Guiding Principle: Start with access pattern clarity (read vs write ratio, latency SLO, distribution topology). Over-optimizing for hypothetical global scale early can inflate complexity.

Services & Identity

Cosmos DB

Multi-model (Core SQL, Mongo, Cassandra, Gremlin, Table), turnkey global distribution, multi-master, RU-based throughput.

Per-partition autoscale
Global consistency levels
Latency SLA (<10ms read)

Table Storage

Very low cost key/attribute store. Partition + row key indexing only. Basic throughput, no global multi-master.

Use for simple entity storage
Minimal indexing
Cheap at scale

Redis Cache

In-memory cache & data structures (lists, sets, streams). Ultra-low latency ephemeral or semi-persistent state.

Hot path acceleration
Pub/Sub & streams
TTL / eviction

Managed Cassandra

Wide-column store for high write scale & linear scalability (via partition strategy). Multi-region replication.

High ingestion workloads
Time-series partition patterns
Open-source ecosystem

Key Differences

Dimension	Cosmos DB	Table Storage	Redis Cache	Cassandra (Managed)
Data Model	Document / Graph / KV / Column APIs	Key / Attribute	In-memory structures	Wide-column
Global Distribution	Native multi-region, multi-master	Single region (geo-redundant optional, not multi-master)	Primary/replicas (regional)	Multi-datacenter replication
Latency Profile	Low (<10ms reads)	Moderate	Very low (<1ms local)	Low (depends on cluster)
Consistency Options	5 tunable levels	Strong (single region) eventual GRS	N/A (eventual via replication)	Tunable (QUORUM choices)
Cost Model	Provisioned / autoscale RU	Storage-centric	Cache tier size	Node/cluster sizing
Secondary Indexing	Automatic (Core), limited in APIs	Only PK/Row key	N/A (key lookups)	Per-table defined (limited)
Use Case Sweet Spot	Multi-API global apps	Cheap simple entities	Session / hot data cache	High write, time-series

Selection Model

Criteria scored 0–10. Models relative FIT (higher is better). Adjust sliders based on workload traits.

Score_Cosmos = 0.22*C_global + 0.15*C_latency + 0.18*C_multiAPI + 0.14*C_consistency + 0.12*C_autoscale + 0.10*C_schemaFlex + 0.09*C_ttl + 0.08*(10 - C_costMin) Score_Table = 0.30*C_costMin + 0.18*(10 - C_multiAPI) + 0.15*(10 - C_consistency) + 0.14*C_simple + 0.13*C_schemaFlex + 0.10*(10 - C_latency) Score_Redis = 0.30*C_latency + 0.18*C_ttl + 0.15*C_hotset + 0.14*C_structures + 0.13*C_throughput + 0.10*(10 - C_persist) Score_Cass = 0.26*C_throughput + 0.18*C_writeHeavy + 0.16*C_partition + 0.14*C_global + 0.14*C_schemaFlex + 0.12*(10 - C_consistency)

Cosmos DB {{vm.scores.cosmos | number:2}}

Table Storage {{vm.scores.table | number:2}}

Redis Cache {{vm.scores.redis | number:2}}

Cassandra {{vm.scores.cass | number:2}}

Recommended: {{vm.recommended.name}} ({{vm.recommended.score | number:2}})

Interpretation Heuristics

If C_latency ≥ 7 AND C_ttl ≥ 5 ⇒ Redis (cache-first pattern); still persist elsewhere.
If C_global ≥ 6 AND C_multiAPI ≥ 6 ⇒ Cosmos DB.
If C_costMin ≥ 7 AND low complexity ⇒ Table Storage.
If C_writeHeavy ≥ 7 AND C_partition ≥ 6 ⇒ Cassandra (or Cosmos Cassandra API).

Anti-Patterns

Using Redis as sole durable store for critical data → risk of loss (unless persistence configured plus backup strategy).
Choosing Cosmos only for small single-region key-value sets with minimal scale (overkill cost vs Table).
Under-specifying partition key design in Cassandra or Cosmos → future hot partitions & throttling.

Summary

Cosmos DB = global multi-model abstraction & tunable consistency; Table = ultra-cheap simple storage; Redis = low-latency ephemeral/hot data; Cassandra = high write, wide-column time-series or IoT scale with careful modeling.