ObservKit / Capacity Planning / OpenSearch Sizing Calculator
Observability utility

OpenSearch Sizing Calculator

Storage for Amazon OpenSearch Service or self-managed OpenSearch: replicas, UltraWarm and cold tiers, shard planning, and the assumptions behind each number.

● Calculated locally in your browser
Capacity inputs
Deployment
Uses the AWS sizing guide: replicas, 5% Linux reserved space and 20% service overhead on hot storage; UltraWarm and cold storage in S3.
Storage tier days
Days must add up to total retention. Warm and cold data live in S3 with primary shards only. UltraWarm needs dedicated master nodes and its indexes are read-only.
Capacity calculation
Total storage · hot to provision + UltraWarm + cold · planning estimate
—
Source over retention —
Primary data (source × index factor) —
Hot data × copies (before overhead) —
Reserved space and service overhead —
Hot · to provision—
UltraWarm · S3—
Cold · S3—

Conservative for Amazon OpenSearch Service. The service reserves 20% of each instance’s storage, but capped at 20 GiB per instance. Because ObservKit does not size nodes, applying 20% to the whole cluster can overestimate, most when instances have large volumes.

Show math

Amazon OpenSearch Service: source × (1 + replicas) × (1 + indexing overhead) ÷ (1 − Linux reserved) ÷ (1 − service overhead), which AWS simplifies to source × (1 + replicas) × 1.45. The 20% service overhead is capped at 20 GiB per instance, so this is a worst-case estimate.

Shard planning Planning estimate
Primary shards / rollover—
Active primary shards—
Estimated shard size—
Total shards on data nodes—
Primary shards retained—
Data nodes needed by the shard limit—

    Replicas are included in the total. Shards in UltraWarm or cold storage do not count toward the per-node limit. The per-node limit depends on the deployment and, on Amazon OpenSearch Service, on the engine version and JVM heap. Without them, the planner shows shard counts but does not estimate data nodes.
    Assumptions & sources
    Every assumption, where it comes from, and its limit
    AssumptionSourceLimitationConfidence
    Hot storage formula with 5% Linux reserved and 20% service overhead applies to Amazon OpenSearch Service only.AWS: Calculating storage requirements.The 20% overhead is capped at 20 GiB per instance, so the formula overestimates when per-node storage is large.High
    Index / source factor 1.1 (indexing overhead 10%): an editable ObservKit planning assumption.AWS: Calculating storage requirements: source plus index is often 110% of the source (an Amazon OpenSearch Service guideline).Not an OpenSearch recommendation for self-managed clusters, where the ratio depends on mappings, codecs and data; measure pri.store.size with _cat/indices?v. The same default is applied to both deployments so they can be compared.Medium
    Replica count defaults to 1.AWS: one replica by default, at least one recommended. OpenSearch: a replica per primary by default.Zero replicas risks data loss; more replicas help read-heavy workloads.High
    UltraWarm and cold storage count primary shards only.AWS: UltraWarm and cold storage: backed by S3, no replicas and none of the hot-storage overhead.UltraWarm needs dedicated master nodes, indexes are read-only, and warm node counts are not modeled.High
    Self-managed planning utilization target 85%.OpenSearch cluster settings: low watermark 85%, high 90%, flood stage 95%.Watermarks apply per node; an aggregate target is a planning estimate, and the low watermark does not stop primaries of new indexes.Medium
    Shard size rule of thumb 10–50 GB (default target 30 GB).OpenSearch: limit shard size to 10–50 GB. AWS: 10–30 GiB for latency-sensitive search, 30–50 GiB for write-heavy workloads such as log analytics.A starting point; performance testing decides the real size.Medium
    Shard limit per data node: self-managed 1,000 by default (configurable); Amazon OpenSearch Service 1,000 up to 2.15 and, from 2.17, 1,000 per 16 GiB of JVM heap up to 4,000.OpenSearch cluster settings: cluster.max_shards_per_node. AWS: Choosing the number of shards.For Amazon OpenSearch Service the limit needs engine version and heap per node; without them no node estimate is shown. AWS also suggests at most 25 shards per GiB of heap, which is not modeled.High
    Growth buffer 25%, applied to source data before overhead.ObservKit planning assumption.AWS's formula takes source data at any given time; set the buffer from your forecast.n/a

    Not modeled: node counts and instance types, EBS volume types and IOPS, UltraWarm node counts, OpenSearch Optimized instances, self-managed warm or searchable-snapshot tiers, snapshots and backups, and the AWS guideline of at most 25 shards per GiB of JVM heap.

    Planning estimates only. Actual OpenSearch capacity depends on mappings, query load, shard strategy, node hardware and operational requirements. OpenSearch and Amazon OpenSearch Service are different products; the deployment switch shows which model applies.

    Worked example: Amazon OpenSearch Service, hot only

    Reference scenario the calculator's defaults: 250 GB/day of source data, 90 days kept hot, 1 replica, index / source factor 1.1 and 25% growth. Open this scenario.

    From daily ingest to hot storage to provision
    StepFormulaResult
    Source over retention250 GB/day × 90 days22.5 TB
    With growth buffer× 1.2528.1 TB
    Stored on nodes× (1 + 1 replica) × index factor 1.161.9 TB
    Reserved space and service overhead÷ 0.95 ÷ 0.80 (AWS worst case)19.5 TB
    Hot storage to provision2.9× the growth-adjusted source81.4 TB

    AWS simplifies the same formula to source × (1 + replicas) × 1.45. The exact terms give a multiplier of 2.9 for one replica.

    Reference scenarios

    Reference scenario comparison points, not recommended layouts. Index / source factor 1.1, 1 replica, 25% growth, 85% planning target for the self-managed row.

    OpenSearch storage by deployment and tier layout
    ScenarioDeploymentTier daysHot to provisionUltraWarmColdTotalLink
    Hot only, 250 GB/day · 90 daysAmazon service90 hot81.4 TB0 MB0 MB81.4 TBOpen this scenario
    Self-managed, same dataSelf-managed90 hot72.8 TB0 MB0 MB72.8 TBOpen this scenario
    One year, all hotAmazon service365 hot330.2 TB0 MB0 MB330.2 TBOpen this scenario
    One year, tieredAmazon service14 hot · 76 UltraWarm · 275 cold12.7 TB26.1 TB94.5 TB133.3 TBOpen this scenario

    Keeping a year hot needs 330.2 TB; moving 351 days to S3-backed tiers needs 133.3 TB, 2.48× less, because warm and cold data carry no replicas and none of the hot-storage overhead. The same 90 days on a self-managed cluster need 72.8 TB: the AWS service overhead does not apply there, but a planning utilization target does.

    Shard planning example

    OpenSearch documents 10–50 GB per shard as the rule of thumb (AWS: 10–30 GiB for latency-sensitive search, 30–50 GiB for write-heavy log analytics). The per-node shard limit depends on deployment and version. The planner divides the indexed data of each rollover by a target shard size and rounds up.

    250 GB/day scenario, daily rollover, 30 GB target
    StepFormulaResult
    Indexed data per rollover250 GB/day × 1.1 × 1 day275 GB
    Primary shards per rolloverceil(275 ÷ 30)10
    Estimated shard size275 ÷ 1027.5 GB
    Primary shards retained10 × 90 rollovers900
    Total shards on data nodesretained × (1 + 1 replica)1,800
    Data nodes needed by the shard limit alone, self-managedceil(total ÷ cluster.max_shards_per_node), default 1,0002
    Same on Amazon OpenSearch ServiceDepends on engine version: 1,000 per node up to 2.15; 1,000 per 16 GiB of JVM heap (max 4,000) from 2.17Not estimated until you set the engine version in Expert mode

    Illustrative example 2 GB/day with daily rollover indexes 2.2 GB per rollover, so each shard is about 2.2 GB, below the 10 GB rule of thumb, and 90 days produce 180 shards on data nodes. Rolling over every 14 days gives shards of about 15.4 GB and 28 shards. Open the 14-day rollover.

    Common mistakes

    1. Applying the Amazon formula to a self-managed cluster, or the reverse. The 5% Linux and 20% service overhead terms are AWS's. On the 250 GB/day scenario the Amazon service model gives 81.4 TB and the self-managed model 72.8 TB. Pick the deployment that matches yours.
    2. Giving UltraWarm and cold storage replicas. They are backed by S3 and count primary shards only. For the one-year tiered scenario, UltraWarm needs 26.1 TB; counting a replica would show 52.3 TB.
    3. Keeping a year of rarely searched data hot. All hot, a year needs 330.2 TB; tiered it needs 133.3 TB.
    4. Planning with zero replicas. Hypothetical example with no replica the 250 GB/day scenario needs 40.7 TB instead of 81.4 TB, but a node loss then loses data. AWS recommends at least one replica.
    5. Assuming no indexing overhead. Hypothetical example with a factor of 1.0 instead of the documented 1.1 the 250 GB/day scenario shrinks to 74 TB, 10% short of the AWS guidance. Measure your own factor.
    6. Daily indexes for small volumes. Many small shards add per-shard overhead: 180 shards of about 2.2 GB, against 28 with a 14-day rollover.
    7. Mixing open source and Amazon service defaults. Open source OpenSearch creates one primary and one replica by default; AWS documents that the Amazon service divides an index into five primary shards by default. Set the shard count explicitly before indexing.

    How OpenSearch sizing is calculated

    Amazon OpenSearch Service
      source(tier)   = daily ingest × tier days × (1 + growth)
      hot to provision = source(hot) × (1 + replicas) × index factor ÷ 0.95 ÷ 0.80
      UltraWarm        = source(warm) × index factor        primary shards only
      cold storage     = source(cold) × index factor        primary shards only
    
    Self-managed OpenSearch (hot only)
      disk to provision = source × (1 + replicas) × index factor ÷ utilization target (85%)
    
    shards per rollover = ceil(daily ingest × index factor × rollover days ÷ target shard size)
    • Decimal units: 1,000 GB = 1 TB.
    • The 0.95 and 0.80 terms are Linux reserved space and the service's reserved storage, applied as AWS's worst case.
    • Not modeled: node and instance counts, EBS volume types, UltraWarm node counts, the 25-shards-per-GiB-of-heap guideline and self-managed warm tiers.

    The common model behind every calculator is in the methodology.

    Sources

    • Calculating storage requirements — Amazon OpenSearch Service documentation. The storage formula, indexing overhead, Linux and service reserved space.
    • Choosing the number of shards — Amazon OpenSearch Service documentation. Shard size by workload, the primary-shard formula, shard limits and the Amazon service's default of five primaries.
    • UltraWarm storage — Amazon OpenSearch Service documentation. Primary-only storage requirements, prerequisites, read-only indexes.
    • Cold storage — Amazon OpenSearch Service documentation. S3-backed storage without replicas or hot-storage overhead.
    • Cluster management settings — OpenSearch documentation (latest). Disk watermarks and cluster.max_shards_per_node.
    • Introduction to OpenSearch — OpenSearch documentation (latest). Default replicas and the 10–50 GB shard rule of thumb.
    • Optimize OpenSearch index shard sizes — OpenSearch blog. Shard sizes by workload and the default of one primary and one replica.

    Last reviewed: · Related: OpenSearch sizing guide · Capacity Planning · Methodology