Cloud & Data Platforms

Store data as flexible JSON or BSON documents rather than rows and columns, so each record carries a nested, evolving shape without a fixed schema.

Enterprise use case: a product-catalog and order service for a retailer, where every product has different attributes and orders embed line items, addresses, and status history in one document.

• The document model
• Modeling and querying
• Aggregation and analytics
• Scale, operations, and the prototype

Prototype built across the 20 lessons: a working catalog-and-orders API on a document store, with nested documents, indexes, an aggregation pipeline for reporting, and a sharded, replicated deployment.

Store data as simple key-value pairs for extremely fast reads and writes, trading rich query power for raw speed and predictable low latency.

Enterprise use case: a session store and rate limiter for a high-traffic web platform, where millions of lookups per second must return in well under a millisecond.

• The key-value model
• Access patterns
• Building the rate limiter
• Persistence, scale, and the prototype

Prototype built across the 20 lessons: a session store and rate limiter serving sub-millisecond lookups, with sound key design, expiry, persistence, and a replicated, highly available setup.

Organize data into rows with dynamic, wide sets of columns, optimized for writing and reading enormous volumes across a distributed cluster with no single point of failure.

Enterprise use case: a time-ordered event and messaging store for a large consumer app, ingesting billions of writes per day across many data centers with always-on availability.

• The wide-column model
• Modeling for the cluster
• Consistency and the write path
• Operations, scale, and the prototype

Prototype built across the 20 lessons: a distributed event and messaging store modeled query-first, with a partitioning and clustering design, tunable consistency, and a multi-node cluster handling high write volume.

Store entities as nodes and relationships as edges, making it natural and fast to traverse deep, interconnected relationships that would be costly joins in a relational database.

Enterprise use case: a fraud-detection and recommendation graph for a bank, linking customers, accounts, devices, and transactions to surface rings and suspicious patterns in real time.

• The graph model
• Querying the graph
• Graph algorithms
• Scale, real-time, and the prototype

Prototype built across the 20 lessons: a fraud-detection and recommendation graph modeling customers, accounts, and transactions, running pattern-matching and pathfinding queries to surface suspicious rings.

Optimize for timestamped measurements written in order and queried over time windows, with efficient storage, retention, and downsampling of high-frequency data.

Enterprise use case: an industrial sensor and metrics platform for a manufacturer, ingesting readings from thousands of machines and serving live dashboards and alerts.

• The time-series model
• Ingesting at scale
• Querying over time
• Dashboards, alerts, and the prototype

Prototype built across the 20 lessons: a sensor and metrics platform ingesting high-frequency readings, with time-window aggregations, retention and downsampling, and live dashboards with alerting.

Persist application objects directly, preserving their structure and relationships without an object-relational mapping layer, so complex object graphs are stored and retrieved as-is.

Enterprise use case: a CAD and engineering-model store for a design firm, where deeply nested object structures must be saved and reloaded with full fidelity and no mapping overhead.

• The object database model
• Storing object graphs
• Querying and transactions
• Fit, operations, and the prototype

Prototype built across the 20 lessons: an application that persists and reloads complex nested object graphs directly, with object queries, transactions, and a demonstration of full-fidelity round-tripping.

Store data by column rather than by row, so analytical queries scan only the columns they need and compress heavily, delivering fast aggregations over huge datasets.

Enterprise use case: a business-intelligence warehouse for a retailer, aggregating billions of sales rows into sub-second dashboards across products, regions, and time.

• Columnar foundations
• Modeling for analytics
• Fast aggregation
• Cost, operations, and the prototype

Prototype built across the 20 lessons: a BI warehouse modeling sales data for fast aggregation, with a tuned schema, materialized roll-ups, and sub-second dashboard queries. This family is also covered in depth by the ClickHouse, Snowflake, and cloud-warehouse programs in this track.

Combine the familiar relational model and strong transactional guarantees with the horizontal, distributed scalability usually associated with NoSQL systems.

Enterprise use case: a globally distributed ledger for a payments company, requiring strongly consistent transactions across regions without giving up SQL or ACID.

• The NewSQL model
• Distributed transactions
• Data distribution
• Operations, scale, and the prototype

Prototype built across the 20 lessons: a strongly consistent, multi-region ledger on a distributed SQL engine, with distributed transactions, region-aware data placement, and a resilient cluster.

Keep data primarily in RAM rather than on disk, delivering ultra-low latency for both transactions and analytics where speed matters more than storage cost.

Enterprise use case: a real-time pricing and risk engine for a trading desk, recomputing positions and exposure in memory as market data streams in.

• The in-memory model
• In-memory processing
• Durability and capacity
• Availability and the prototype

Prototype built across the 20 lessons: a real-time pricing and risk engine holding working data in memory, recomputing exposure on streaming input, with a persistence and high-availability strategy.

Store high-dimensional embedding vectors and search them by similarity, powering semantic search, recommendations, and retrieval-augmented generation for AI applications.

Enterprise use case: a semantic search and retrieval layer for a company knowledge base, letting an AI assistant answer questions grounded in the organization's own documents.

• Vectors and embeddings
• Indexing and search
• Retrieval-augmented generation
• Scale, operations, and the prototype

Prototype built across the 20 lessons: a semantic-search layer over a document set, embedding content, indexing it for similarity search, and wiring it into a retrieval-augmented AI assistant.

Index text for fast full-text search, ranking, filtering, and aggregation, so applications can search large document and log collections with relevance scoring and near-real-time results.

Enterprise use case: a product search and log-analytics platform for an online store, powering typo-tolerant product search and real-time operational dashboards over application logs.

• Search foundations
• Querying and relevance
• Aggregations and log analytics
• Scale, operations, and the prototype

Prototype built across the 20 lessons: a search and log-analytics platform with an inverted index, relevance-ranked product search, faceted filtering, and near-real-time log dashboards.

Support several data models, document, graph, key-value, and more, within a single engine, so one system can serve varied workloads without stitching together many databases.

Enterprise use case: a unified customer-360 platform for an enterprise, combining document profiles, a relationship graph, and key-value preferences in one database.

• The multi-model idea
• Documents and key-value
• The relationship graph
• Design, trade-offs, and the prototype

Prototype built across the 20 lessons: a customer-360 platform using document, graph, and key-value models in a single engine, queried together, with a discussion of when this beats specialized stores.