Free audit

View Audit Scope
JusDBAzure Cosmos DB Consulting · RU/s FinOps · Hierarchical Partition Keys · Multi-Region

Eliminate HTTP 429 throttling and cut Cosmos DB RU/s spend without sacrificing single-digit millisecond latency.

Azure Cosmos DB delivers global multi-region distribution and single-digit millisecond point reads when partition keys, indexing policies, and SDK connection modes are engineered properly. When they are not, a single skewed partition key triggers `HTTP 429` throttling at 15% aggregate utilization, wildcard `/*` indexing inflates write costs 4x, and cross-partition queries burn through Autoscale budgets. JusDB’s principal NoSQL architects re-engineer partition topologies, indexing policies, Change Feed pipelines, and multi-region consistency across NoSQL, MongoDB, Cassandra, and Gremlin APIs.
Our engineering team is in India (IST, UTC+5:30). Or request a free audit of one database instance.
  • 15 minutes P1 response target under a 24x7 support agreement
  • 30-60% typical RU/s reduction via selective indexing
  • Live Change Feed re-partitioning to Hierarchical Keys
  • 24 supported database technologies

Cosmos DB Architecture Matrix

Request Unit (RU/s) Optimization: Provisioned vs Autoscale vs Serverless

FINOPS · RU RIGHTSIZING

Cosmos DB bills for provisioned Request Units (`RU/s`) divided evenly across underlying physical partitions. Over-indexing every JSON path (`/*`) and choosing the wrong capacity mode inflates Azure cloud spend by 40% to 70%.

We audit per-partition `NormalizedRUConsumption`, customize indexing policies (`includedPaths` / `excludedPaths` / composite indexes), and model Manual Provisioned vs Autoscale vs Serverless break-even thresholds.

Request an RU/s FinOps audit

Trusted across Azure Cosmos DB, MongoDB, Cassandra & multi-cloud enterprise architectures

  • Innoviti
  • Blitz
  • Freecharge
  • Nango
  • Recochain
  • Screen Facts
  • Nexora
  • WeCredit

01 · Production Failure & Cost Modes

Six Azure Cosmos DB bottlenecks we resolve inside physical partitions, indexes, and SDKs.

Raising your Autoscale ceiling rarely solves HTTP 429 throttling when a single physical partition is hot. We diagnose the exact partition key, indexing path, or SDK transport bottleneck driving latency and Azure spend.

Telemetry Signal / ErrorArchitectural Root CauseHow We VerifyProduction Remediation
HTTP 429 · RequestRateTooLarge at 15% total RU utilizationProvisioned `RU/s` is divided equally across all N physical partitions. A skewed partition key routes bursts to a single physical partition (peaking `NormalizedRUConsumption`) while the other N-1 partitions sit idle.Query Azure Monitor Log Analytics `CDBPartitionKeyRUConsumption` and `CDBDataPlaneRequests` grouped by `PartitionKey` and `PartitionId`.Refactor to Hierarchical Partition Keys (`[TenantId, UserId, SessionId]`) or synthetic high-cardinality keys via a live Change Feed container migration.
HTTP 403 Substatus 1014 · Partition key reached 20 GB limitA single logical partition key value (such as a large enterprise `tenantId` or static status bucket) accumulates more than the hard 20 GB storage ceiling per logical partition.Inspect `CDBPartitionKeyStatistics` in Azure Diagnostics to identify logical keys approaching 15+ GB of storage.Adopt multi-level Hierarchical Partition Keys so storage scales across sub-keys while preserving single-prefix query targeting, and enable analytical TTL archival.
CROSS_PARTITION_FANOUT · 150+ RU per simple SELECT queryOmitting the partition key from query predicates or running `ORDER BY` across multiple properties without a matching composite index forces the SDK to fan out across every physical partition.Inspect `x-ms-request-charge` and `PopulateQueryMetrics` (`RetrievedDocumentCount` vs `OutputDocumentCount` and physical partitions visited).Include the partition key or hierarchical prefix in every point read/query, embed frequently joined child arrays, and declare explicit `compositeIndexes` in the container indexing policy.
INDEX_ALL_WRITE_BLOAT · 35+ RU per 2 KB document upsertLeaving the default indexing policy (`includedPaths: ["/*"]`) enabled on deep JSON documents forces Cosmos DB to update inverted index trees for dozens of never-queried attributes on every write.Compare `Create`/`Upsert` request charges in `CDBDataPlaneRequests` before and after selective path exclusion in staging.Switch to an explicit allow-list indexing policy (`excludedPaths: ["/*"]` with targeted `includedPaths` and `compositeIndexes`), cutting write RU consumption by 40% to 60%.
AUTOSCALE_PEAK_TRAP · Paying 1.5x rate 24 hours a dayA brief unthrottled batch job or poorly indexed query spikes consumption for two minutes each hour, pinning Autoscale at its maximum `RU/s` tier (which bills at 1.5x the manual provisioned rate per RU).Correlate hourly `ProvisionedThroughput` step changes in Azure Monitor with `OperationName` and caller client IPs in `CDBDataPlaneRequests`.Rate-limit background batch ingestion, move spiky cron workloads to dedicated containers, and switch steady high-duty containers from Autoscale to Manual Provisioned + Azure Cosmos DB Reserved Capacity.
SDK_SNAT_EXHAUSTION · High p99 tail latency in Gateway modeInstantiating `CosmosClient` per request instead of as a singleton, or running in `ConnectionMode.Gateway` over HTTPS, adds an extra network hop and exhausts Azure App Service / AKS outbound SNAT ports.Inspect Cosmos SDK diagnostics JSON (`ClientSideRequestStats`, `TransportException`, and Gateway vs `rntbd://` Direct TCP latency).Enforce singleton `CosmosClient` lifecycle, switch to `ConnectionMode.Direct` (TCP `rntbd`), configure `ApplicationPreferredRegions`, and enable aggressive startup connection warm-up.
Evaluation Vector
JusDB DBRE
In-House DBALegacy AgencyDeveloper Generalist
Multi-Model API Selection (NoSQL/SQL vs MongoDB vCore vs Cassandra)Audits query access patterns and wire-protocol compatibility to choose NoSQL (Core SQL) for global scale, MongoDB vCore for native aggregation pipelines, or Cassandra API, avoiding costly multi-API architectural dead-ends.Defaults to classic Cosmos MongoDB API for all legacy migrations, encountering aggregation operator feature gaps and RU billing penalties.Treats Cosmos DB as a drop-in relational database replacement, porting normalized tables directly without evaluating NoSQL document hierarchies.Selects APIs based on familiar SDK syntax without auditing underlying indexing semantics, partition boundaries, or RU cost models.
High-Cardinality Logical Partition Key Modeling (20GB Boundary Control)Models high-cardinality synthetic and compound partition keys, enforcing strict 20GB physical partition boundaries and uniform throughput distribution to eliminate cross-partition fan-out.Uses low-cardinality keys (e.g. status or date strings), triggering the 20GB partition limit breach and hot-partition throughput starvation.Omits partition key strategy during schema design, causing Cosmos DB to fall back on inefficient random partitions or single-partition bottlenecks.Writes queries without partition key filters in the WHERE clause, triggering cross-partition fan-out queries that multiply RU consumption by partition count.
429 RequestRateTooLarge Throttling Elimination & Client RetriesEliminates HTTP 429 exceptions via server-side partition rebalancing, client SDK connection tuning (Direct Mode, TCP), custom exponential backoff policies, and batch bulk executor optimizations.Relies entirely on default SDK retry policies, leading to client-side thread starvation, connection pool exhaustion, and end-user request timeouts.Advises increasing provisioned RU/s limits as the only fix for 429 errors, dramatically inflating monthly Azure cloud spend.Catches 429 exceptions in application code and retries immediately in tight loops, exacerbating cluster throttling storms.
Autoscale RU/s Capacity RightsizingAudits normalized RU/s utilization profiles across peak and off-peak hours, rightsizing autoscale maximum throughput and converting steady workloads to reserved capacity, with savings measured against the current bill.Over-provisions manual RU/s capacity to avoid 429 alerts, leaving up to 70% of provisioned throughput unutilized during off-peak hours.Configures unmonitored high autoscale ceilings with 10x dynamic scale headroom, triggering massive unexpected cloud billing spikes.Operates in manual provisioning mode without workload profiling, oscillating between severe under-provisioning and costly over-provisioning.
Consistency Level Calibration (Strong, Bounded, Session, Eventual)Mathematically evaluates consistency requirements across five tiers (Strong, Bounded Staleness, Session, Consistent Prefix, Eventual), optimizing session token propagation to balance latency and RU costs.Configures Strong consistency globally across all containers, doubling write RU costs and incurring severe multi-region latency overhead.Leaves all workloads on default Session consistency without understanding read-your-own-writes session token propagation across microservices.Switches to Eventual consistency indiscriminately to save RU costs, introducing dirty reads and data anomalies in transactional workflows.
Multi-Region Multi-Master Active-Active Topology & Conflict ResolutionArchitects multi-region active-active write topologies with custom conflict resolution policies (LWW timestamp vs merge Stored Procedures), designed around the availability and recovery targets agreed for the workload.Relies on default Last-Writer-Wins (LWW) conflict resolution without custom conflict procedures, leading to silent data overwrites during concurrent cross-region updates.Avoids multi-region deployments altogether due to complexity, leaving mission-critical systems vulnerable to single-region Azure datacenter outages.Enables multi-region writes without scoping replication latency, triggering cross-region data sync races and bloated cross-region egress charges.

02 · Consulting Workstreams

Deep engineering across partition keys, RU/s FinOps, and Change Feed.

Each workstream delivers production-ready Bicep/Terraform manifests, container indexing policies, and benchmarked query rewrites.

01 · PARTITION KEY ARCHITECTURE

High-Cardinality & Hierarchical Partition Key Modeling

A container's partition key cannot be mutated in place. We analyze access patterns, query selectivity, and 20 GB logical partition growth to design Hierarchical Partition Keys (`Subpartitioning`) or synthetic keys, and execute live container-to-container migrations via the Change Feed.

Hierarchical Partition Keys · CDBPartitionKeyStatistics · 20 GB cap mitigation

02 · RU/s & INDEX FINOPS

Indexing Policy Customization, Query Tuning & RU/s FinOps

We replace `/*` wildcard indexing with surgical `includedPaths`, `excludedPaths`, and `compositeIndexes`. We rewrite high-RU cross-partition SQL queries into 1-RU point reads (`ReadItemAsync(id, partitionKey)`) and right-size Provisioned, Autoscale, Serverless, and Reserved Capacity commitments.

x-ms-request-charge · compositeIndexes · Autoscale vs Manual FinOps

03 · CONSISTENCY & MULTI-REGION

Five-Level Consistency Engineering & Multi-Region Active-Active

We map each workload to the right consistency level (`Strong`, `Bounded Staleness`, `Session`, `Consistent Prefix`, `Eventual`), balancing RPO/RTO against the `2x` read RU multiplier of `Strong`/`Bounded Staleness`. For multi-region writes, we engineer conflict resolution and SDK regional failover.

Session vs Bounded Staleness · Multi-region writes · Conflict resolution

04 · CHANGE FEED & FABRIC

Change Feed Event Pipelines, Vector Search & Fabric Mirroring

We architect resilient event-driven pipelines using the Change Feed Processor (`LatestVersion` and `AllVersionsAndDeletes` modes) with properly partitioned lease containers. We configure integrated `diskANN` vector indexing for AI RAG workloads and Mirroring in Microsoft Fabric for HTAP analytics.

Change Feed Processor · diskANN vector index · Microsoft Fabric Mirroring

05 · MULTI-API & DOCUMENTDB

NoSQL, MongoDB (RU vs Azure DocumentDB vCore), Cassandra & Gremlin

We advise and execute across all Cosmos DB APIs: native API for NoSQL, API for MongoDB (both RU-based and vCore-based Azure DocumentDB), API for Apache Cassandra, and API for Gremlin. We remediate aggregation pipeline and graph traversal RU amplification.

API for NoSQL · Azure DocumentDB (vCore) · Cassandra CQL · Gremlin TinkerPop

06 · SRE & SECURITY

SDK Direct-Mode Tuning, Continuous PITR Backups & 24x7 Operations (Where Contracted)

We harden production estates with Azure Private Endpoints, customer-managed keys (CMK), role-based data-plane RBAC (`AzCosmosRoleDefinition`), and Continuous Backup (7-day or 30-day PITR). Our SREs monitor `NormalizedRUConsumption` 24x7 under a 24x7 support agreement.

ConnectionMode.Direct · Continuous PITR · Data-plane RBAC · KQL alerts

03 · Responsibility Boundary & Response Targets

What Microsoft Azure manages vs what JusDB architects own.

Azure manages physical replica availability and platform infrastructure, but Microsoft does not choose your partition keys, prune your wildcard indexes, or stop a cross-partition query from exhausting your RU budget.

Shared Responsibility Matrix (Azure Cosmos DB)

Global Azure Infrastructure, Physical Replica Sets & SLA Backing

Microsoft Azure Control Plane

Microsoft Azure manages physical servers, SSD storage rings, automatic physical partition splits, and regional backbone networking.

JusDB Cosmos DB Architects

We architect multi-region topologies, Private Link networking, CMK encryption, and Continuous PITR backup policies across subscriptions.

Logical Partition Key Selection, 20 GB Ceiling & Hot-Partition Prevention

Microsoft Azure Control Plane

Enforces the 20 GB logical partition limit (`HTTP 403` substatus `1014`) and throttles hot physical partitions with `HTTP 429`.

JusDB Cosmos DB Architects

We design high-cardinality and Hierarchical Partition Keys, monitor `CDBPartitionKeyStatistics`, and execute live Change Feed re-partitioning.

Indexing Policy (`/*`), Query RU Charges & Autoscale Capacity Tiering

Microsoft Azure Control Plane

Defaults to indexing every JSON property (`/*`) and bills for the highest `RU/s` consumed in any hour under Autoscale.

JusDB Cosmos DB Architects

We author custom `excludedPaths` and `compositeIndexes`, convert 100-RU scans into 1-RU point reads, and right-size Provisioned vs Autoscale tiers.

SDK Connection Governance, Change Feed Leases & 24x7 Incident Response (Where Contracted)

Microsoft Azure Control Plane

Provides client SDKs (.NET, Java, Node.js, Python, Go) and Azure Monitor diagnostic telemetry.

JusDB Cosmos DB Architects

We tune singleton `ConnectionMode.Direct` SDK configs, scale Change Feed consumers, and provide 24x7 DBA response under a 24x7 support agreement.

Target Incident Response Matrix

P1 to P4 Engineering Targets (15m / 30m / 60m / 90m)

When a production container hits an HTTP 429 storm or a multi-region replication anomaly, the page goes to a senior engineer. Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

P1 · CriticalTarget: 15 minutes

Production database down, primary unreachable, data corruption risk, or active failover event.

24x7 on-call (under your service agreement) · Direct PagerDuty, Opsgenie, or phone page plus incident bridge

P2 · HighTarget: 30 minutes

Severe latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.

24x7 on-call (under your service agreement) · On-call alert plus shared Slack or Teams channel

P3 · MediumTarget: 60 minutes

Non-critical slow query regression, staging issue, backup warning, or replication check alert.

24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

P4 · LowTarget: 90 minutes

Configuration question, index advisory, planned schema review, or general operational request.

24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

Dealing with active HTTP 429 throttling or a 20 GB logical partition limit? Open an emergency escalation →

04 · Interactive Partition & RU Simulator

See how Hierarchical Partition Keys and custom indexing eliminate 429s.

Compare a hot-partitioned container running wildcard indexing against a re-partitioned hierarchical design and a global active-active topology with Change Feed streaming.

Azure Cosmos DB Partitioning & Consistency Simulator

Application and routing

Gateway HTTPS Client to Hot Physical Partition #1 (Max RU) while Partitions #2-#8 Idle

THROTTLED · HTTP 429 + 18 GB KEY
  • Physical Partition #1 (tenantId = 'enterprise-hq')

    Saturated NormalizedRUConsumption · 18.4 GB Size

    HTTP 429 THROTTLING · APPROACHING 20 GB CAP

  • Physical Partitions #2 to #8

    Receiving < 6% Traffic Despite Equal RU Allocation

    85% PROVISIONED RU/s WASTED

  • Default Indexing Policy (includedPaths: ['/*'])

    Indexing 64 Unqueried JSON Properties on Every Write

    38 RU PER UPSERT · AUTOSCALE PINNED AT MAX

Because provisioned RU/s is split evenly across all physical partitions, a skewed partition key (`tenantId`) saturates Partition #1 and triggers HTTP 429 errors even when 85% of the container's total RU capacity is unused.

05 · Representative Deliverable

Log Analytics KQL forensics and allow-list indexing JSON.

Every Cosmos DB audit delivers exact KQL queries for your Azure Monitor workspace alongside tested JSON indexing policies and Terraform/Bicep patches that reduce RU burn on deployment.

  • 01Physical Partition Telemetry: Correlates `NormalizedRUConsumption` with `Http429` metrics at 5-minute granularity to distinguish hot partitions from genuine capacity exhaustion.
  • 02Hot-Key KQL Attribution: Queries `CDBPartitionKeyRUConsumption` to identify the exact logical `PartitionKey` and `PartitionKeyRangeId` driving throttling.
  • 03Allow-List + Composite Indexing: Excludes `/*` and `_etag` while declaring exact `compositeIndexes` to accelerate multi-field `ORDER BY` queries.

cosmosdb-429-kql-and-indexing-policy.json

# 1. Azure CLI: Inspect 429 throttled requests & NormalizedRUConsumption (last 24h)
az monitor metrics list \
  --resource "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-prod/providers/Microsoft.DocumentDB/databaseAccounts/cosmos-prod-orders" \
  --metric "TotalRequestUnits" "NormalizedRUConsumption" "Http429" \
  --interval PT5M \
  --aggregation Total Maximum

# 2. Log Analytics KQL: Pinpoint hot logical PartitionKey values causing 429s
CDBPartitionKeyRUConsumption
| where TimeGenerated > ago(6h)
| where DatabaseName == "commerce" and CollectionName == "orders"
| summarize TotalRUs = sum(RequestCharge), PeakRUsPerSec = max(RequestCharge)
    by PartitionKey, PartitionKeyRangeId
| order by TotalRUs desc
| take 20

# 3. Production Indexing Policy: Exclude wildcard /* and index only queried paths
{
  "indexingMode": "consistent",
  "automatic": true,
  "includedPaths": [
    { "path": "/tenantId/?" },
    { "path": "/orderStatus/?" },
    { "path": "/createdAt/?" }
  ],
  "excludedPaths": [
    { "path": "/*" },
    { "path": "/"_etag"/?" }
  ],
  "compositeIndexes": [
    [
      { "path": "/tenantId", "order": "ascending" },
      { "path": "/orderStatus", "order": "ascending" },
      { "path": "/createdAt", "order": "descending" }
    ]
  ]
}

06 · Engagement Models & Scope

Flexible engagements from RU FinOps audits to SRE operations (24x7 on-call under your service agreement).

Start with a fixed-fee RU and partition key assessment, execute a live Change Feed re-partitioning sprint, or retain our engineers for ongoing 24x7 Cosmos DB operations under a 24x7 support agreement.

Implementation SprintRecommended

Live Change Feed Re-Partitioning & Query Remediation Sprint

Hands-on execution to migrate hot or 20 GB-constrained containers to Hierarchical Partition Keys via the Change Feed, refactor high-RU queries into point reads, or migrate MongoDB / Cassandra workloads into Cosmos DB.

Included in scope

  • Live container-to-container re-partitioning using Change Feed Processor + dual-read verification
  • Refactoring of top RU-consuming SQL / MongoDB aggregation queries and stored procedures
  • Multi-region active-active failover testing, Continuous PITR setup, and Fabric Mirroring integration
Fixed-Scope Audit

Cosmos DB RU/s FinOps, Partition Key & 429 Diagnostic Audit

A surgical engineering audit of your Azure Cosmos DB accounts: `CDBPartitionKeyRUConsumption` hot-key forensics, indexing policy rightsizing, top-query `x-ms-request-charge` profiling, and Provisioned vs Autoscale vs Reserved Capacity modeling.

Included in scope

  • Per-container indexing policy rewrite (`excludedPaths` / `compositeIndexes`) with projected RU savings
  • Identification of hot partitions, 20 GB logical partition risks, and cross-partition fan-out queries
  • SDK configuration audit (`ConnectionMode.Direct`, singleton lifecycle, retry policies, preferred regions)
Ongoing Retainer

Managed Cosmos DB SRE, FinOps Governance & On-Call DBA Support

Continuous operational and cost governance for mission-critical Azure Cosmos DB estates, backed by 24x7 incident response under a 24x7 support agreement.

Included in scope

  • P1 critical acknowledgment target: 15 minutes under a 24x7 support agreement
  • Continuous monitoring of `NormalizedRUConsumption`, HTTP 429 spikes, and logical partition growth
  • Monthly RU/s FinOps reviews, index policy governance on CI/CD schema changes, and DR failover drills

Procurement and security

Ready for legal and security review.

All engagements operate under strict NDA with Azure PIM / least-privilege role assignments inside your tenant.
  • Mutual NDA before any access
  • Named individual accounts only
  • Read-only access by default
  • ISO 27001 & SOC 2 Type II: aligned, certification in progress
  • Measured FinOps Impact

    Typical 30% to 60% RU/s reduction via selective indexing, point reads & tier rightsizing

  • Support Coverage

    2 to 4 hours (During covered business hours) · 15 minutes under a 24x7 support agreement

  • Security & Access Posture

    ISO 27001 & SOC 2 Type II: aligned, certification in progress · Least-privilege Azure PIM / RBAC inside your tenant

  • Engagement Flexibility

    Fixed-fee RU & partition audits, Change Feed migration sprints, or monthly SRE retainers

07 · Technical & FinOps FAQ

Common questions on Azure Cosmos DB consulting.

Direct engineering answers on HTTP 429 throttling, the 20 GB logical partition limit, Autoscale vs Provisioned FinOps, consistency levels, and Azure DocumentDB.

Still have a question?

Ask it on a scoping call. No production access needed.

Book a 30-min scoping call (opens Google Calendar in a new tab)

Why are we seeing HTTP 429 (RequestRateTooLarge) errors when our overall Cosmos DB RU utilization is under 20%?

Azure Cosmos DB divides a container's provisioned `RU/s` evenly across all of its underlying physical partitions. If your container has 10,000 RU/s across 10 physical partitions, each physical partition receives strictly 1,000 RU/s. When a low-cardinality or skewed partition key routes bursts of reads or writes to a single logical partition, that one physical partition saturates its `NormalizedRUConsumption` ceiling and returns HTTP `429` throttling responses even while the other 9 physical partitions sit nearly idle. We pinpoint the offending keys via `CDBPartitionKeyRUConsumption` in Log Analytics and remediate them with Hierarchical Partition Keys or synthetic composite keys.

How do we change a partition key or fix a 20 GB logical partition limit without downtime?

Cosmos DB does not allow mutating a container's partition key definition in place, and any single logical partition key value that reaches 20 GB triggers `HTTP 403` (substatus `1014`). To re-partition a live production container without downtime, we create a new target container configured with Hierarchical Partition Keys (up to 3 levels in the API for NoSQL, such as `[/tenantId, /userId, /yearMonth]`), deploy a Change Feed Processor worker to stream all historical and real-time documents from the source container into the new container, verify parity via shadow dual-reads, and flip application writes to the new container.

When should we use Manual Provisioned RU/s vs Autoscale vs Serverless in Cosmos DB?

Each RU under Autoscale costs 1.5x the hourly rate of Manual Provisioned throughput, and Autoscale bills at the highest RU/s reached during any second of a given hour. Therefore, Autoscale only saves money when your workload's average hourly peak is below 66% of its maximum capacity. If a container runs steady traffic or suffers from hourly batch spikes that pin Autoscale at its ceiling, Manual Provisioned throughput paired with 1-year or 3-year Azure Cosmos DB Reserved Capacity is substantially cheaper. Serverless is ideal for intermittent dev/test or low-duty workloads with fewer than ~15 million RU per month per container.

How much RU consumption can we save by customizing the Cosmos DB indexing policy?

By default, Cosmos DB indexes every property of every JSON document (`includedPaths: ["/*"]`). On write-heavy containers storing documents with 30 to 100 attributes, maintaining inverted index entries for unqueried fields accounts for 50% to 75% of the write RU charge. By setting `excludedPaths: ["/*"]` and explicitly including only the 3 to 6 properties used in `WHERE` clauses alongside targeted `compositeIndexes` for multi-field `ORDER BY` queries, teams routinely cut write RU consumption by 40% to 60% and shrink index storage overhead.

How do Cosmos DB's five consistency levels impact RU cost and multi-region latency?

Read operations under `Session`, `Consistent Prefix`, and `Eventual` consistency consume half as many RUs (`1 RU` for a 1 KB point read) as reads under `Strong` or `Bounded Staleness` (`2 RUs` for a 1 KB point read, because the engine must read from two quorum replicas). Furthermore, `Strong` consistency cannot be enabled on accounts with multiple write regions or across more than a single region without paying full WAN round-trip latency on every write. Nearly all enterprise OLTP microservices achieve optimal price-performance on `Session` consistency, using `Bounded Staleness` only where cross-session global ordering is mandatory.

What is the difference between Cosmos DB for MongoDB (RU) and Azure DocumentDB (vCore)?

Cosmos DB offers two distinct architectures for MongoDB workloads: the RU-based architecture shares the multi-tenant Cosmos DB storage engine (billed per Request Unit with a 20 GB logical partition limit), whereas vCore-based Cosmos DB for MongoDB (now branded as Azure DocumentDB, built on the open-source DocumentDB engine) provisions dedicated VM compute and disk instances with no 20 GB partition limit and native support for complex MongoDB aggregation pipelines and vector search without per-query RU charges. We help teams choose between them and migrate between MongoDB Atlas, RU, and Azure DocumentDB.

Should we use Microsoft Fabric Mirroring or Synapse Link for Cosmos DB analytics?

Microsoft has closed Azure Synapse Link for Cosmos DB to new projects in favor of Mirroring in Microsoft Fabric. For new HTAP and analytical reporting pipelines, we configure Microsoft Fabric Mirroring or Change Feed streaming into Azure Event Hubs / Delta Lake so heavy analytical scans never consume RUs from your transactional containers.

What response times do you provide for production Azure Cosmos DB incidents?

Under a 24x7 support agreement, our target initial response times are: P1 (Critical) within 15 minutes; P2 (High) within 30 minutes; P3 (Medium) within 60 minutes; P4 (Low) within 90 minutes. During standard business-hours consulting retainers, our response target is 2 to 4 hours. Every alert connects directly to a senior NoSQL & Azure database reliability engineer.

Talk to a Principal Azure Cosmos DB Architect

Ready to stop HTTP 429 throttling and cut your Cosmos DB RU bill?

Share your container RU consumption metrics, partition key structure, or multi-region latency requirements for a concrete engineering assessment.