> For the complete documentation index, see [llms.txt](https://docs.pharos.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pharos.ai/open-telemetry/hermes/sizing-and-cost.md).

# Sizing & Cost

Starting compute shapes per Hermes profile and runtime, the ELF load-unit model, and what drives AWS and Azure cost at each profile.

This page turns the `local` / `standard` / `scaled` vocabulary from [Scaling Profiles](https://docs.pharos.ai/open-telemetry/hermes/scaling.md) into starting compute shapes and a cost model. It estimates infrastructure only — not observability-backend ingest, Salesforce licensing, or enterprise discounts. Validate the starting shapes against your own event volume after the first week of production traffic.

***

## Profile Summary

| Profile    | Use                                                             | Compute style                          | State                    | Scaling                                                 |
| ---------- | --------------------------------------------------------------- | -------------------------------------- | ------------------------ | ------------------------------------------------------- |
| `local`    | Development, troubleshooting, mapping validation                | One process or local Docker            | File                     | None                                                    |
| `standard` | Normal production, predictable traffic, 1–20 orgs               | Production services with managed state | DynamoDB / Table Storage | Small fixed counts, modest vertical sizing              |
| `scaled`   | Larger production with bursty, multi-org ELF traffic, 5–20 orgs | Split services with shared leases      | Managed state + leases   | ELF workers scale out; Iris and RTEM stay single-active |

Choose by calculation: a single process with acceptable data loss → `local`; managed state and 1–3 ELF workers → `standard`; shared leases, 4–20 ELF workers, and per-org fairness → `scaled`.

***

## Starting Shapes

**`standard`** — direct OTLP export by default, ELF backlog does not grow continuously:

| Runtime                                      | Size                 | Count                                                             |
| -------------------------------------------- | -------------------- | ----------------------------------------------------------------- |
| Iris                                         | 0.5 vCPU / 1 GiB     | 1 active per org/topic                                            |
| Argus RTEM                                   | 0.5–1 vCPU / 1–2 GiB | 1 active per org × channel group                                  |
| Argus ELF live                               | 1–2 vCPU / 2–4 GiB   | 1 service with a small worker pool (`hermes.elf.parallelism` 2–3) |
| Combined supervisor (all runtimes, one task) | 0.5 vCPU / 1 GiB     | 1 — handles up to \~20 orgs at moderate event rates               |

**`scaled`** — separate RTEM, ELF live, and backfill services; ELF live scales on `argus_elf_lag_seconds` (target ≈60 s) between a minimum and maximum worker count you derive below; backfill runs as a lower-priority job.

**`local`** — 0.25–1 vCPU / 0.5–2 GiB per runtime, file-backed state, no leases. Sized for correctness, not throughput.

***

## The ELF Load-Unit Model

Only Argus ELF is sized by data volume. Iris is bounded by the org's Platform Event delivery allocation; RTEM by observed event rate and `org × channel` stream count.

```
1 load unit = 1 GB/hour sustained = 24 GB/day (raw EventLogFile volume, before OTLP expansion)

hourly_load_units = org_count × gb_per_hour_per_org
raw_MBps          = hourly_load_units × 1000 / 3600
target_MBps       = raw_MBps × burst_factor × safety_factor      # safety 1.3; burst 1 sustained, 2 for burst sizing
worker_count      = ceil(target_MBps / measured_worker_MBps)
```

| Sustained load | Daily raw | Raw MB/s |
| -------------- | --------- | -------- |
| 1 GB/h         | 24 GB     | 0.28     |
| 10 GB/h        | 240 GB    | 2.78     |
| 20 GB/h        | 480 GB    | 5.56     |
| 83.3 GB/h      | 2.0 TB    | 23.1     |
| 100 GB/h       | 2.4 TB    | 27.8     |

***

## Per-Worker Throughput and Cloud Translation

Per-worker ELF decode throughput (decode → mapping → identity → dedup, no export) was measured with a Go benchmark on an Apple M1 Max workstation on 2026-05-30 at about **64 MB/s**. Cloud vCPUs are several-fold slower per core; the planning figures below are derived from per-core ratios:

| Target                    | Per-core ratio vs. the benchmark core | Planning per-worker rate |
| ------------------------- | ------------------------------------- | ------------------------ |
| AWS Graviton4 (ARM)       | ≈ 1/2.7                               | ≈ 24 MB/s                |
| AWS Graviton3 / Azure ARM | ≈ 1/3.3                               | ≈ 19 MB/s                |
| x86 Fargate / shared vCPU | ≈ 1/5                                 | ≈ 13 MB/s                |

Because ELF parsing is CPU-bound, plan ELF worker and task counts 2–4× higher than the workstation figure implies, treat per-worker capacity as a band, and prefer Graviton — closest to the benchmark core and roughly 20 % cheaper than x86 Fargate for the same CPU-bound work. Size CPU at 70 % target utilisation (`required_vcpu = estimated_vcpu / 0.70`); size memory from observed heap plus 30 % headroom rather than scaling it with CPU.

Iris converter throughput (≈600K records/s on Apple M4 Max developer hardware, Go microbenchmark) is not a sizing input: Iris is bounded by Salesforce Platform Event delivery at tens of events per second per org, which any shape converts with orders of magnitude of headroom.

**Worked example** — 8 orgs at 10 GB/h each on Graviton: 80 load units → 22.2 MB/s raw → ×1.3 safety = 28.9 MB/s sustained, 57.8 MB/s burst → `ceil(28.9 / 24) = 2` workers sustained, `ceil(57.8 / 24) = 3` at burst. Set ELF min 2, max 4, and let lag-based autoscaling move between them.

***

## Cost Model

```
runtime_hourly_cost  = runtime_count × (vcpu × vcpu_hour_price + memory_gib × gib_hour_price)
monthly_compute_cost = runtime_hourly_cost × 730
nat_data_cost        = data_processed_GB × nat_price_per_GB
otlp_output_GB       = raw_input_GB × otel_expansion_factor
```

Always-on compute per unit, public on-demand list prices captured 2026-05-27 (AWS `us-west-1`, Azure `eastus`):

| Unit             | AWS Fargate / month | Azure Container Apps / month |
| ---------------- | ------------------- | ---------------------------- |
| 0.5 vCPU / 1 GiB | $20.72              | $39.42                       |
| 1 vCPU / 2 GiB   | $41.45              | $78.84                       |
| 2 vCPU / 4 GiB   | $82.90              | $157.68                      |
| 4 vCPU / 8 GiB   | $165.80             | $315.36                      |

Azure Container Apps compute is about 1.9× the equivalent Fargate shape at list price; Azure's Consumption plan bills less when a replica is idle, which is why the [Azure runbook](https://docs.pharos.ai/open-telemetry/configuration/azure.md#cost) shows ranges.

Network, when traffic crosses a NAT gateway (data processing only — not internet egress, private connectivity, or backend ingest):

| Load                       | AWS NAT / month | Azure NAT / month |
| -------------------------- | --------------- | ----------------- |
| 1 load unit (730 GB)       | $35             | $33               |
| 83.3 load units (2 TB/day) | $2,919          | $2,736            |
| 100 load units             | $3,504          | $3,285            |

***

## What Dominates, and Controls

* **`local` and small `standard`:** compute is the main line; on AWS the NAT gateway's hourly charge (\~$35/month) is the largest fixed item in the private-subnet stack. A single combined task lands at **$56–58/month** on AWS.
* **`standard`:** compute and platform logging are visible; state-store cost stays negligible until ELF scale.
* **`scaled`:** ELF worker compute grows, but NAT or egress data processing and backend ingest can dominate as soon as OTLP output crosses public paths — at 2 TB/day raw, network is an order of magnitude above compute.

Controls for scaled deployments: keep Salesforce download and backend routes private where possible; avoid routing OTLP output through NAT when a private endpoint or gateway exists; enable OTLP compression when the backend supports it; keep debug logging off and cap platform log ingestion; pause or throttle backfill while live traffic is high; tag resources and track cost by runtime, org, and export route. The per-cloud tables — component breakdowns and budget setup — are on the [AWS](https://docs.pharos.ai/open-telemetry/configuration/aws.md#cost) and [Azure](https://docs.pharos.ai/open-telemetry/configuration/azure.md#cost) runbooks.

***

## Related

<table data-view="cards"><thead><tr><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>📊 Scaling Profiles</strong></td><td>Why Iris and RTEM stop at standard and only ELF scales out</td><td><a href="https://docs.pharos.ai/open-telemetry/hermes/scaling.md">Scaling Profiles</a></td></tr><tr><td><strong>📑 EventLogFile</strong></td><td>The workload the load-unit model sizes</td><td><a href="https://docs.pharos.ai/open-telemetry/hermes/argus/elf.md">EventLogFile</a></td></tr><tr><td><strong>🟠 AWS Deployment</strong></td><td>Component cost table and the task-size variables</td><td><a href="https://docs.pharos.ai/open-telemetry/configuration/aws.md">AWS Deployment</a></td></tr><tr><td><strong>🔵 Azure Deployment</strong></td><td>Scenario cost table and the replica-size variables</td><td><a href="https://docs.pharos.ai/open-telemetry/configuration/azure.md">Azure Deployment</a></td></tr></tbody></table>
