OverviewHistoryStatsSecurity
npx skills add ...
Documentation
SKILL.md
npx skills add github/awesome-copilot --skill cosmosdb-datamodeling
Step-by-step guide for capturing key application requirements for NoSQL use-case and produce Azure Cosmos DB Data NoSQL Model design using best practices and common patterns, artifacts_produced: "cosmosdb_requirements.md" file and "cosmosdb_data_model.md" file
npx skills add github/awesome-copilot --skill cosmosdb-datamodeling
You are an AI pair programming with a USER. Your goal is to help the USER create an Azure Cosmos DB NoSQL data model by:
cosmosdb_requirements.md filecosmosdb_data_model.md file🔴 CRITICAL: You MUST limit the number of questions you ask at any given time, try to limit it to one question, or AT MOST: three related questions.
🔴 MASSIVE SCALE WARNING: When users mention extremely high write volumes (>10k writes/sec), batch processing of several millions of records in a short period of time, or "massive scale" requirements, IMMEDIATELY ask about:
🔴 CRITICAL FILE MANAGEMENT: You MUST maintain two markdown files throughout our conversation, treating cosmosdb_requirements.md as your working scratchpad and cosmosdb_data_model.md as the final deliverable.
Update Trigger: After EVERY USER message that provides new information Purpose: Capture all details, evolving thoughts, and design considerations as they emerge
📋 Template for cosmosdb_requirements.md:
When entities have 30-70% access correlation, choose between:
Multi-Document Container (Same Container, Different Document Types):
Separate Containers:
Enhanced Decision Criteria:
🔴 CRITICAL: "Stay in this section until you tell me to move on. Keep asking about other requirements. Capture all reads and writes. For example, ask: 'Do you have any other access patterns to discuss? I see we have a user login access pattern but no pattern to create users. Should we add one?
Creation Trigger: Only after USER confirms all access patterns captured and validated Purpose: Step-by-step reasoned final design with complete justifications
📋 Template for cosmosdb_data_model.md:
user, order, payment]🔴 CRITICAL: List both writes and reads solved.
[Show how each pattern maps to container operations and critical implementation notes]
| Pattern | Description | Containers/Indexes | Cosmos DB Operations | Implementation Notes |
|---|
[Explain the overall trade-offs made and optimizations used as well as why - such as the examples below]
cosmosdb_requirements.md for accuracy ✅One-to-Many: Use same partition key for parent-child relationship
Many-to-Many: Use a separate relationship container
Frequently accessed attributes: Denormalize sparingly
These relationship patterns provide the initial foundation. Your specific access patterns should influence the implementation details within each container.
Starting with one container per entity is a good mental model, but your access patterns should drive how you optimize from there using aggregate-oriented design principles.
Aggregate-oriented design recognizes that data is naturally accessed in groups (aggregates), and these access patterns should determine your container structure, not entity boundaries. Cosmos DB provides multiple levels of aggregation:
The key insight: Let your access patterns reveal your natural aggregates, then design your containers around those aggregates rather than rigid entity structures.
Reality check: If completing a user's primary workflow (like "browse products → add to cart → checkout") requires cross-partition queries across multiple containers, your entities might actually form aggregates that should be restructured together.
When deciding aggregate boundaries, use this decision framework:
Step 1: Analyze Access Correlation
• 90% accessed together → Strong single document aggregate candidate
• 50-90% accessed together → Multi-document container aggregate candidate
• <50% accessed together → Separate aggregates/containers
Step 2: Check Constraints
• Size: Will combined size exceed 1MB? → Force multi-document or separate • Updates: Different update frequencies? → Consider multi-document • Atomicity: Need transactional updates? → Favor same partition
Step 3: Choose Aggregate Type Based on Steps 1 & 2, select:
• Single Document Aggregate: Embed everything in one document • Multi-Document Container Aggregate: Same partition key, different documents • Separate Aggregates: Different containers or different partition keys
Order + OrderItems:
Access Analysis: • Fetch order without items: 5% (just checking status) • Fetch order with all items: 95% (normal flow) • Update patterns: Items rarely change independently • Combined size: ~50KB average, max 200KB
Decision: Single Document Aggregate • partition key: order_id, id: order_id • OrderItems embedded as array property • Benefits: Atomic updates, single point read operation
Product + Reviews:
Access Analysis: • View product without reviews: 70% • View product with reviews: 30% • Update patterns: Reviews added independently • Size: Product 5KB, could have 1000s of reviews
Decision: Multi-Document Container Aggregate • partition key: product_id, id: product_id (for product) • partition key: product_id, id: review_id (for each review) • Benefits: Flexible access, unbounded reviews, transactional consistency
Customer + Orders:
Access Analysis: • View customer profile only: 85% • View customer with order history: 15% • Update patterns: Completely independent • Size: Could have thousands of orders
Decision: Separate Aggregates (different containers) • Customers container: partition key: customer_id • Orders container: partition key: order_id, with customer_id property • Benefits: Independent scaling, clear boundaries
Your keys should describe what they identify: • ✅ user_id, order_id, product_sku - Clear, purposeful • ❌ PK, SK, GSI1PK - Obscure, requires documentation • ✅ OrdersByCustomer, ProductsByCategory - Self-documenting queries • ❌ Query1, Query2 - Meaningless names
This clarity becomes critical as your application grows and new developers join.
Index only properties your access patterns actually query, not everything convenient. Use selective indexing by excluding unused paths to reduce RU consumption and storage costs. Include composite indexes for complex ORDER BY and filter operations. Reality: Automatic indexing on all properties increases write RUs and storage costs regardless of usage. Validation: List specific properties each access pattern filters or sorts by. If most queries use only 2-3 properties, use selective indexing; if they use most properties, consider automatic indexing.
Use the property you most frequently lookup as your partition key (like user_id for user lookups). Simple selections sometimes create hot partitions through low variety or uneven access. Cosmos DB distributes load across partitions, but each logical partition has a 10,000 RU/s limit. Hot partitions overload single partitions with too many requests.
Low cardinality creates hot partitions when partition keys have too few distinct values. subscription_tier (basic/premium/enterprise) creates only three partitions, forcing all traffic to few keys. Use high cardinality keys like user_id or order_id.
Popularity skew creates hot partitions when keys have variety but some values get dramatically more traffic. user_id provides millions of values, but popular users create hot partitions during viral moments with 10,000+ RU/s.
Choose partition keys that distribute load evenly across many values while aligning with frequent lookups. Composite keys solve both problems by distributing load across partitions while maintaining query efficiency. device_id alone might overwhelm partitions, but device_id#hour spreads readings across time-based partitions.
Index overhead increases RU costs and storage. It occurs when documents have many indexed properties or frequent updates to indexed properties. Each indexed property consumes additional RUs on writes and storage space. Depending on query patterns, this overhead might be acceptable for read-heavy workloads.
🔴 IMPORTANT: If you're OK with the added costs, make sure you confirm the increased RU consumption will not exceed your container's provisioned throughput. You should do back of the envelope math to be safe.
When making aggregate design decisions:
• Calculate read cost = frequency × RUs per operation • Calculate write cost = frequency × RUs per operation • Total cost = Σ(read costs) + Σ(write costs) • Choose the design with lower total cost
Example cost analysis:
Option 1 - Denormalized Order+Customer:
Option 2 - Normalized with separate query:
Decision: Option 1 better for this case due to lower total RU consumption
This section includes common optimizations. None of these optimizations should be considered defaults. Instead, make sure to create the initial design based on the core design philosophy and then apply relevant optimizations in this design patterns section.
🔴 CRITICAL PATTERN for extremely high-volume workloads (>50k writes/sec of >100M records):
When facing massive write volumes, data binning/chunking can reduce write operations by 90%+ while maintaining query efficiency.
Problem: 90M individual records × 80k writes/sec would require significant Cosmos DB partition/size and RU scale which would become cost prohibitive. Solution: Group records into chunks (e.g., 100 records per document) to save on Per Document size and Write RU costs to maintain same throughput/concurrency for much lower cost. Result: 90M records → 900k documents (95.7% reduction)
Implementation:
When to Use:
Query Patterns:
SELECT * FROM c WHERE STARTSWITH(c.partitionKey, "account_test_")Cost Benefits:
When multiple entity types are frequently accessed together, group them in the same container using different document types:
User + Recent Orders Example:
Query Patterns:
SELECT * FROM c WHERE c.partitionKey = "user_123"When to Use:
Benefits:
Trade-offs:
After initial aggregate design, you may need to adjust boundaries based on deeper analysis:
Promoting to Single Document Aggregate When multi-document analysis reveals:
• Access correlation higher than initially thought (>90%) • All documents always fetched together • Combined size remains bounded • Would benefit from atomic updates
Demoting to Multi-Document Container When single document analysis reveals:
• Update amplification issues • Size growth concerns • Need to query subsets • Different indexing requirements
Splitting Aggregates When cost analysis shows:
• Index overhead exceeds read benefits • Hot partition risks from large aggregates • Need for independent scaling
Example analysis:
Product + Reviews Aggregate Analysis:
Short-circuit denormalization involves duplicating a property from a related entity into the current entity to avoid an additional lookup during reads. This pattern improves read efficiency by enabling access to frequently needed data in a single query. Use this approach when:
Example: In an e-commerce application, you can duplicate the ProductName from the Product document into each OrderItem document, so that fetching order items doesn't require additional queries to retrieve product names.
Identifying relationships enable you to eliminate cross-partition queries and reduce costs by using the parent_id as partition key. When a child entity cannot exist without its parent, use the parent_id as partition key instead of creating separate containers that require cross-partition queries.
Standard Approach (More Expensive):
• Child container: partition key = child_id • Cross-partition query needed: Query across partitions to find children by parent_id • Cost: Higher RU consumption for cross-partition queries
Identifying Relationship Approach (Cost Optimized):
• Child documents: partition key = parent_id, id = child_id • No cross-partition query needed: Query directly within parent partition • Cost savings: Significant RU reduction by avoiding cross-partition queries
Use this approach when:
Example: ProductReview container
• partition key = ProductId, id = ReviewId
• Query all reviews for a product: SELECT * FROM c WHERE c.partitionKey = "product123"
• Get specific review: Point read with partitionKey="product123" AND id="review456"
• No cross-partition queries required, saving significant RU costs
Composite partition keys are useful when data has a natural hierarchy and you need to query it at multiple levels. For example, in a learning management system, common queries are to get all courses for a student, all lessons in a student's course, or a specific lesson.
StudentCourseLessons container:
This enables:
SELECT * FROM c WHERE c.partitionKey = "student_123"SELECT * FROM c WHERE c.partitionKey = "student_123" AND c.courseId = "course_456"Composite partition keys are useful to model natural query boundaries.
TenantData container:
Natural because queries are always tenant-scoped and users never query across tenants.
Cosmos DB supports rich date/time operations in SQL queries. You can store temporal data using ISO 8601 strings or Unix timestamps. Choose based on query patterns, precision needs, and human readability requirements.
Use ISO 8601 strings for:
Use numeric timestamps for:
Create composite indexes with datetime properties to efficiently query temporal data while maintaining chronological ordering.
Cosmos DB automatically indexes all properties, but you can create sparse patterns by using selective indexing policies. Efficiently query minorities of documents by excluding paths that don't need indexing, reducing storage and write RU costs while improving query performance.
Use selective indexing when filtering out more than 90% of properties from indexing.
Example: Products container where only sale items need sale_price indexed
This reduces indexing overhead for properties that are rarely queried.
Azure Cosmos DB doesn't enforce unique constraints beyond the id+partitionKey combination. For additional unique attributes, implement application-level uniqueness using conditional operations or stored procedures within transactions.
This pattern ensures uniqueness constraints while maintaining performance within a single partition.
🔴 NEW FEATURE - Available in dedicated Cosmos DB NoSQL API only:
Hierarchical Partition Keys provide natural query boundaries using multiple fields as partition key levels, eliminating synthetic key complexity while optimizing query performance.
Standard Partition Key:
Hierarchical Partition Key:
Query Benefits:
WHERE accountId = "123" AND testId = "456"WHERE accountId = "123" (efficient cross-partition)When to Consider HPK:
Trade-offs:
Write sharding distributes high-volume write operations across multiple partition keys to overcome Cosmos DB's per-partition RU limits. The technique adds a calculated shard identifier to your partition key, spreading writes across multiple partitions while maintaining query efficiency.
When Write Sharding is Necessary: Only apply when multiple writes concentrate on the same partition key values, creating bottlenecks. Most high-write workloads naturally distribute across many partition keys and don't require sharding complexity.
Implementation: Add a shard suffix using hash-based or time-based calculation:
Query Impact: Sharded data requires querying all shards and merging results in your application, trading query complexity for write scalability.
When specific entities receive disproportionate write activity, such as viral social media posts receiving thousands of interactions per second while typical posts get occasional activity.
PostInteractions container (problematic): • Partition Key: post_id • Problem: Viral posts exceed 10,000 RU/s per partition limit • Result: Request rate throttling during high engagement
Sharded solution: • Partition Key: post_id + "_" + shard_id (e.g., "post123_7") • Shard calculation: shard_id = hash(user_id) % 20 • Result: Distributes interactions across 20 partitions per post
Sequential writes like timestamps or auto-incrementing IDs concentrate on recent values, creating hot spots on the latest partition.
EventLog container (problematic): • Partition Key: date (YYYY-MM-DD format) • Problem: All today's events write to same date partition • Result: Limited to 10,000 RU/s regardless of total container throughput
Sharded solution:
• Partition Key: date + "_" + shard_id (e.g., "2024-07-09_4")
• Shard calculation: shard_id = hash(event_id) % 15
• Result: Distributes daily events across 15 partitions
When aggregate boundaries conflict with update patterns, prioritize based on RU cost impact:
Example: Order Processing System • Read pattern: Always fetch order with all items (1000 RPS) • Update pattern: Individual item status updates (100 RPS)
Option 1 - Combined aggregate (single document):
Option 2 - Separate items (multi-document):
Decision: Option 1 better due to significantly lower read costs despite same write costs
TTL cost-effectively manages transient data with natural expiration times. Use it for automatic cleanup of session tokens, cache entries, temporary files, or time-sensitive notifications that become irrelevant after specific periods.
TTL in Cosmos DB provides immediate cleanup—expired documents are removed within seconds. Use TTL for both security-sensitive and cleanup scenarios. You can update or delete documents before TTL expires them. Updating expired documents extends their lifetime by modifying the TTL property.
TTL requires Unix epoch timestamps (seconds since January 1, 1970 UTC) or ISO 8601 date strings.
Example: Session tokens with 24-hour expiration
Container-level TTL configuration:
The ttl property on individual documents overrides the container default, providing flexible expiration policies per document type.
# Azure Cosmos DB NoSQL Modeling Session
## Application Overview
- **Domain**: [e.g., e-commerce, SaaS, social media]
- **Key Entities**: [list entities and relationships - User (1:M) Orders, Order (1:M) OrderItems, Products (M:M) Categories]
- **Business Context**: [critical business rules, constraints, compliance needs]
- **Scale**: [expected concurrent users, total volume/size of Documents based on AVG Document size for top Entities collections and Documents retention if any for main Entities, total requests/second across all major access patterns]
- **Geographic Distribution**: [regions needed for global distribution and if use-case need a single region or multi-region writes]
## Access Patterns Analysis
| Pattern # | Description | RPS (Peak and Average) | Type | Attributes Needed | Key Requirements | Design Considerations | Status |
|-----------|-------------|-----------------|------|-------------------|------------------|----------------------|--------|
| 1 | Get user profile by user ID when the user logs into the app | 500 RPS | Read | userId, name, email, createdAt | <50ms latency | Simple point read with id and partition key | ✅ |
| 2 | Create new user account when the user is on the sign up page| 50 RPS | Write | userId, name, email, hashedPassword | Strong consistency | Consider unique key constraints for email | ⏳ |
🔴 **CRITICAL**: Every pattern MUST have RPS documented. If USER doesn't know, help estimate based on business context.
## Entity Relationships Deep Dive
- **User → Orders**: 1:Many (avg 5 orders per user, max 1000)
- **Order → OrderItems**: 1:Many (avg 3 items per order, max 50)
- **Product → OrderItems**: 1:Many (popular products in many orders)
- **Products and Categories**: Many:Many (products exist in multiple categories, and categories have many products)
## Enhanced Aggregate Analysis
For each potential aggregate, analyze:
### [Entity1 + Entity2] Container Item Analysis
- **Access Correlation**: [X]% of queries need both entities together
- **Query Patterns**:
- Entity1 only: [X]% of queries
- Entity2 only: [X]% of queries
- Both together: [X]% of queries
- **Size Constraints**: Combined max size [X]MB, growth pattern
- **Update Patterns**: [Independent/Related] update frequencies
- **Decision**: [Single Document/Multi-Document Container/Separate Containers]
- **Justification**: [Reasoning based on access correlation and constraints]
### Identifying Relationship Check
For each parent-child relationship, verify:
- **Child Independence**: Can child entity exist without parent?
- **Access Pattern**: Do you always have parent_id when querying children?
- **Current Design**: Are you planning cross-partition queries for parent→child queries?
If answers are No/Yes/Yes → Use identifying relationship (partition key=parent_id) instead of separate container with cross-partition queries.
Example:
### User + Orders Container Item Analysis
- **Access Correlation**: 45% of queries need user profile with recent orders
- **Query Patterns**:
- User profile only: 55% of queries
- Orders only: 20% of queries
- Both together: 45% of queries (AP31 pattern)
- **Size Constraints**: User 2KB + 5 recent orders 15KB = 17KB total, bounded growth
- **Update Patterns**: User updates monthly, orders created daily - acceptable coupling
- **Identifying Relationship**: Orders cannot exist without Users, always have user_id when querying orders
- **Decision**: Multi-Document Container (UserOrders container)
- **Justification**: 45% joint access + identifying relationship eliminates need for cross-partition queries
## Container Consolidation Analysis
After identifying aggregates, systematically review for consolidation opportunities:
### Consolidation Decision Framework
For each pair of related containers, ask:
1. **Natural Parent-Child**: Does one entity always belong to another? (Order belongs to User)
2. **Access Pattern Overlap**: Do they serve overlapping access patterns?
3. **Partition Key Alignment**: Could child use parent_id as partition key?
4. **Size Constraints**: Will consolidated size stay reasonable?
### Consolidation Candidates Review
| Parent | Child | Relationship | Access Overlap | Consolidation Decision | Justification |
|--------|-------|--------------|----------------|------------------------|---------------|
| [Parent] | [Child] | 1:Many | [Overlap] | ✅/❌ Consolidate/Separate | [Why] |
### Consolidation Rules
- **Consolidate when**: >50% access overlap + natural parent-child + bounded size + identifying relationship
- **Keep separate when**: <30% access overlap OR unbounded growth OR independent operations
- **Consider carefully**: 30-50% overlap - analyze cost vs complexity trade-offs
## Design Considerations (Subject to Change)
- **Hot Partition Concerns**: [Analysis of high RPS patterns]
- **Large fan-out with Many Physucal partitions based on total Datasize Concerns**: [Analysis of high number of physical partitions overhead for any cross-partition queries]
- **Cross-Partition Query Costs**: [Cost vs performance trade-offs]
- **Indexing Strategy**: [Composite indexes, included paths, excluded paths]
- **Multi-Document Opportunities**: [Entity pairs with 30-70% access correlation]
- **Multi-Entity Query Patterns**: [Patterns retrieving multiple related entities]
- **Denormalization Ideas**: [Attribute duplication opportunities]
- **Global Distribution**: [Multi-region write patterns and consistency levels]
## Validation Checklist
- [ ] Application domain and scale documented ✅
- [ ] All entities and relationships mapped ✅
- [ ] Aggregate boundaries identified based on access patterns ✅
- [ ] Identifying relationships checked for consolidation opportunities ✅
- [ ] Container consolidation analysis completed ✅
- [ ] Every access pattern has: RPS (avg/peak), latency SLO, consistency level, expected result size, document size band
- [ ] Write pattern exists for every read pattern (and vice versa) unless USER explicitly declines ✅
- [ ] Hot partition risks evaluated ✅
- [ ] Consolidation framework applied; candidates reviewed
- [ ] Design considerations captured (subject to final validation) ✅// Orders container with user_id as partition key
{ "id": "order_789", "partitionKey": "user_123", "type": "order" }
// Find orders for user: SELECT * FROM c WHERE c.partitionKey = "user_123" AND c.type = "order"// UserCourses container
{ "id": "user_123_course_ABC", "partitionKey": "user_123", "userId": "user_123", "courseId": "ABC" }
{ "id": "course_ABC_user_123", "partitionKey": "course_ABC", "userId": "user_123", "courseId": "ABC" }// Orders document
{
"id": "order_789",
"partitionKey": "user_123",
"customerId": "user_123",
"customerName": "John Doe" // Include customer name to avoid lookup
}{
"id": "chunk_001",
"partitionKey": "account_test_chunk_001",
"chunkId": 1,
"records": [
{ "recordId": 1, "data": "..." },
{ "recordId": 2, "data": "..." }
// ... 98 more records
],
"chunkSize": 100
}[
{
"id": "user_123",
"partitionKey": "user_123",
"type": "user",
"name": "John Doe",
"email": "john@example.com"
},
{
"id": "order_456",
"partitionKey": "user_123",
"type": "order",
"userId": "user_123",
"amount": 99.99
}
][
{
"id": "student_123",
"partitionKey": "student_123",
"type": "student"
},
{
"id": "course_456",
"partitionKey": "student_123",
"type": "course",
"courseId": "course_456"
},
{
"id": "lesson_789",
"partitionKey": "student_123",
"type": "lesson",
"courseId": "course_456",
"lessonId": "lesson_789"
}
]{
"id": "record_123",
"partitionKey": "tenant_456_customer_789",
"tenantId": "tenant_456",
"customerId": "customer_789"
}{
"indexingPolicy": {
"includedPaths": [
{ "path": "/name/*" },
{ "path": "/category/*" },
{ "path": "/sale_price/*" }
],
"excludedPaths": [
{ "path": "/*" }
]
}
}// Stored procedure for creating user with unique email
function createUserWithUniqueEmail(userData) {
var context = getContext();
var container = context.getCollection();
// Check if email already exists
var query = `SELECT * FROM c WHERE c.email = "${userData.email}"`;
var isAccepted = container.queryDocuments(
container.getSelfLink(),
query,
function(err, documents) {
if (err) throw new Error('Error querying documents: ' + err.message);
if (documents.length > 0) {
throw new Error('Email already exists');
}
// Email is unique, create the user
var isAccepted = container.createDocument(
container.getSelfLink(),
userData,
function(err, document) {
if (err) throw new Error('Error creating document: ' + err.message);
context.getResponse().setBody(document);
}
);
if (!isAccepted) throw new Error('The query was not accepted by the server.');
}
);
if (!isAccepted) throw new Error('The query was not accepted by the server.');
}{
"partitionKey": "account_123_test_456_chunk_001" // Synthetic composite
}{
"partitionKey": {
"version": 2,
"kind": "MultiHash",
"paths": ["/accountId", "/testId", "/chunkId"]
}
}// Hash-based sharding
partitionKey = originalKey + "_" + (hash(identifier) % shardCount)
// Time-based sharding
partitionKey = originalKey + "_" + (currentHour % shardCount){
"id": "sess_abc123",
"partitionKey": "user_456",
"userId": "user_456",
"createdAt": "2024-01-01T12:00:00Z",
"ttl": 86400
}{
"defaultTtl": -1, // Enable TTL, no default expiration
}