AWS CloudWatch vs OpenObserve / SigNoz Cost & FinOps Calculator

Cloud FinOps & Observability Engineering

AWS CloudWatch vs OpenObserve / SigNoz Cost Calculator

Compare monthly AWS CloudWatch log ingestion, storage, and metric fees against self-hosted OpenObserve (S3 Parquet) and SigNoz (ClickHouse). Uncover up to 85% FinOps savings.

Telemetry & Workload Profile


GB/day

Monthly ingestion: ~3,000 GB/mo


days


GB/day

CloudWatch Logs Insights scans cost $0.005 per GB.


metrics

$0.30 per metric/mo for first 10,000 metrics.


Monthly FinOps Cost Breakdown

AWS CloudWatch Monthly Bill
$1,747.50
$1,500 Ingest + $90 Storage + $7.50 Queries + $150 Metrics

Self-Hosted Monthly Expense
$156.90
$150 EC2 compute (c6i.large) + $6.90 S3 Storage

Annual Net Savings & ROI
Monthly Reduction:
$1,590.60 / mo (91.0%)
Annual Projected Savings:
$19,087 / year

Free Embeddable Widget

Embed this AWS CloudWatch vs OpenObserve / SigNoz Cost & FinOps Calculator on Your Website

Add this interactive, privacy-first calculator to your blog or web application. 100% free and mobile-responsive.

The AWS CloudWatch Ingestion Tax: Breaking Down the Hidden 2,000% Markup

Across engineering organizations operating on Amazon Web Services, AWS CloudWatch Logs is routinely the single largest hidden driver of cloud bill shock. While AWS compute (EC2) and storage (S3) operate at highly competitive margins, CloudWatch employs an aggressive pricing structure designed to capture exorbitant margins on high-throughput microservices:

  • The $0.50 per GB Ingestion Tax: Storing 1 GB of data on standard AWS S3 costs just $0.023 per month. Ingesting that same 1 GB into CloudWatch Logs costs $0.50 upfront—representing a massive 2,073% markup over underlying storage infrastructure before retention storage fees even begin.
  • The Query Scan Tax: Executing ad-hoc investigative queries in CloudWatch Logs Insights charges $0.005 per GB of uncompressed data scanned. A team debugging an outage across 10 TB of historical logs incurs $50.00 for a single regex query, creating financial anxiety around incident response.
  • Custom Metric Gouging: Publishing application performance metrics (e.g., shopping cart checkout latency, active WebSocket connections) costs $0.30 per metric per month. A Kubernetes cluster tracking 2,500 container metrics generates an automatic $750/month bill strictly for telemetry reporting.

Architectural Comparison: CloudWatch vs OpenObserve vs SigNoz vs Loki

Architecture Dimension AWS CloudWatch Logs OpenObserve (Rust + S3 Parquet) SigNoz (ClickHouse + Zstd)
Underlying Storage Tier Proprietary AWS DynamoDB/S3 hybrid Standard AWS S3 / MinIO (Parquet files) Local NVMe SSD / ClickHouse columnar
Ingestion Pricing $0.50 / GB upfront $0.00 (Pure EC2 compute cost) $0.00 (Pure EC2 compute cost)
Compression Efficiency Standard Gzip (~3x) Snappy/Zstandard Parquet (~10x to 14x) Columnar Zstandard (~7x to 9x)
Query Scanning Surcharge $0.005 / GB scanned $0.00 (Unlimited SQL queries) $0.00 (Unlimited ClickHouse SQL)
Unified Tracing & Metrics Fragmented across X-Ray & CloudWatch Native unified Logs, Metrics & Traces Native OpenTelemetry APM & Tracing

Production Migration Architecture: OpenTelemetry Collector DaemonSet

Migrating Kubernetes logs and metrics away from CloudWatch to OpenObserve requires deploying an OpenTelemetry Collector DaemonSet that pipes logs directly to self-hosted S3 storage:

# /etc/otel-collector/config.yaml - Kubernetes Log Pipeline
receivers:
  filelog:
    include: [/var/log/pods/*/*/*.log]
    exclude: [/var/log/pods/kube-system_*/*/*.log]
    start_at: end

processors:
  batch:
    send_batch_size: 10000
    timeout: 5s
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 20

exporters:
  otlphttp/openobserve:
    endpoint: "https://openobserve.internal.vpc/api/default"
    headers:
      Authorization: "Basic ${OPENOBSERVE_INGEST_TOKEN}"

service:
  pipelines:
    logs:
      receivers: [filelog]
      processors: [memory_limiter, batch]
      exporters: [otlphttp/openobserve]

Frequently Asked Questions: CloudWatch FinOps & Cost Optimization

How does CloudWatch Logs Infrequent Access (IA) tier work?

AWS introduced the CloudWatch Logs Infrequent Access tier, which cuts ingestion fees by 50% ($0.25/GB instead of $0.50/GB). However, IA strips out advanced features—such as metric filters, live log tailing, automated alarms, and embedded dashboards. Self-hosted OpenObserve or SigNoz provides full real-time querying at 90% lower cost than even the IA tier.

Can OpenObserve run directly on AWS S3 without local disk storage?

Yes! OpenObserve is stateless. It buffers incoming telemetry in local memory for 5 seconds, encodes the data into highly compressed Apache Parquet columnar files, and pushes the files directly to AWS S3. Query nodes read Parquet metadata directly from S3, requiring zero expensive persistent EBS volumes.

What is the operational maintenance overhead of self-hosting SigNoz?

For small to mid-sized engineering teams ingesting under 250 GB/day, SigNoz deploys in a single Helm command on Kubernetes with ClickHouse managing storage compaction automatically. Operational maintenance involves approximately 1 to 2 hours per month for backup validation and version upgrades.

Production Incident Runbook: Mitigating CloudWatch Telemetry Bill Shocks & Log Storms

An unexpected surge in application log volume—often triggered by unhandled exception loops, recursive AWS Lambda invocations, or debug logging inadvertently deployed to production—can generate tens of gigabytes of logs per hour. At AWS CloudWatch’s $0.50 per GB ingestion fee, a 48-hour unmitigated log storm can easily generate thousands of dollars in surprise cloud charges. When telemetry spikes occur, DevOps and Site Reliability Engineering teams must execute this emergency containment runbook:

  1. Identify High-Ingestion Log Groups: Immediately run the following AWS CLI command to isolate the log group driving anomalous volume:
    aws logs describe-log-groups --order-by LastEventTime --query "logGroups[*].[logGroupName,storedBytes]" --output table

    Alternatively, inspect the IncomingBytes metric in CloudWatch Metrics aggregated across log groups over the past 3 hours.

  2. Set Immediate Retention Lifecycles: CloudWatch log groups default to “Never Expire”, which continuously inflates $0.03/GB-mo storage costs. Enforce an immediate 7-day or 14-day retention policy across all active non-compliance log groups:
    aws logs put-retention-policy --log-group-name "/aws/ecs/production-api" --retention-in-days 14
  3. Deploy an In-Line Edge Filter with Vector or FluentBit: To immediately halt bill growth without taking down upstream application services, intercept log streams before they leave the VPC. Drop high-frequency non-essential log lines (such as health check 200 OK pings or trace spans) using a Vector transform:
    [transforms.filter_noise]
    type = "filter"
    inputs = ["app_logs"]
    condition = '!match(string!(.message), r\'(GET /health|HTTP/1.1 200 OK)\')'
  4. Enforce Log Sampling on Exception Bursts: If a microservice crashes in a tight retry loop, apply client-side token bucket rate limiting or circuit breaking to drop duplicated stack traces exceeding 50 events per second.
  5. Configure AWS Budget Emergency Kill-Switches: Establish an AWS CloudWatch billing alarm paired with an SNS topic and an AWS Lambda function that triggers dynamic rate limiting or temporarily scales down runaway worker pools when ingestion exceeds budget thresholds.

Cloud Observability Total Cost of Ownership (TCO): CloudWatch vs OpenObserve vs SigNoz vs Datadog

Engineering leadership evaluating enterprise observability platforms must look beyond base ingestion rates to evaluate query scanning costs, indexed field charges, retention tiers, and compute overhead. The comparison below models a mid-sized Kubernetes microservices workload generating 100 GB/day (3,000 GB/month) of raw telemetry with a 30-day retention requirement:

Architecture Dimension AWS CloudWatch OpenObserve (Self-Hosted S3) SigNoz (Self-Hosted ClickHouse) Datadog (SaaS Enterprise)
Ingestion Pricing $0.50 / GB ($1,500/mo) $0.00 (Self-managed compute ~$120/mo) $0.00 (Self-managed compute ~$160/mo) $0.10 – $0.25 / GB ingested ($300 – $750/mo)
Storage Compression Proprietary (~2x compression) Columnar Parquet (~10x – 14x compression) ClickHouse ZSTD (~7x – 9x compression) Proprietary / Indexed tiering
Monthly Storage Cost (30 Days) $0.03 / GB ($90/mo) S3 Standard: ~$6.90/mo (300 GB stored) EBS gp3: ~$32.00/mo (400 GB stored) Indexed retention: $1.70/mil events ($150 – $450/mo)
Query Scanning Surcharge $0.005 / GB scanned ($75/mo on 50 GB/day) $0.00 (Local compute scanning) $0.00 (ClickHouse vectorized queries) Included in seat licenses / API limits
Custom Metrics Cost (500 Metrics) $0.30 / metric ($150/mo) $0.00 (Native Prometheus exposition) $0.00 (Native OpenTelemetry metrics) $5.00 / 100 custom metrics ($25/mo)
Total Monthly Expenditure $1,815.00 / month $126.90 / month (-93% Savings) $192.00 / month (-89% Savings) $950.00 – $1,400.00 / month

Production-Hardened Vector.dev Pipeline: Routing Logs to S3 & OpenObserve

The most reliable method to slash AWS CloudWatch bills by 85% to 95% is implementing an in-VPC telemetry routing layer using Vector. Vector aggregates logs from ECS, EKS, and EC2, applies schema normalizations, drops unneeded health-check noise, and writes compressed Parquet files directly to S3 while sending a sampled 5% stream to CloudWatch for native AWS alarms:

# /etc/vector/vector.toml - Production Telemetry Router
[sources.kubernetes_logs]
type = "kubernetes_logs"

[transforms.filter_noise]
type = "filter"
inputs = ["kubernetes_logs"]
condition = '''
!match(string!(.message), r'(kube-probe|healthz|readyz|ELB-HealthChecker)')
'''

[transforms.sample_critical_alarms]
type = "sample"
inputs = ["filter_noise"]
rate = 20  # 1 in 20 non-critical logs sent to CloudWatch

# Sink 1: OpenObserve Ingestion via OpenTelemetry / HTTP
[sinks.openobserve_cluster]
type = "http"
inputs = ["filter_noise"]
uri = "http://openobserve.monitoring.svc.cluster.local:5080/api/default/default/_json"
method = "post"
encoding.codec = "json"
auth.strategy = "basic"
auth.user = "admin@zelobiz.com"
auth.password = "${OPENOBSERVE_API_TOKEN}"

# Sink 2: Direct Parquet Backup to AWS S3 (Cold Compliance Archive)
[sinks.s3_cold_storage]
type = "aws_s3"
inputs = ["filter_noise"]
bucket = "zelobiz-telemetry-archive-useast1"
region = "us-east-1"
key_prefix = "year=%Y/month=%m/day=%d/"
compression = "zstd"
batch.max_bytes = 104857600  # 100 MB parquet chunks
batch.timeout_secs = 300

# Sink 3: Minimal CloudWatch Ingestion for Native AWS Alarms
[sinks.aws_cloudwatch_minimal]
type = "aws_cloudwatch_logs"
inputs = ["sample_critical_alarms"]
group_name = "/aws/eks/zelobiz-prod/critical-sampled"
stream_name = "pod-{{ kubernetes.pod_name }}"
region = "us-east-1"

CloudWatch Logs Insights: High-Performance Query Optimization Cheatsheet

Because CloudWatch Logs Insights bills $0.005 for every gigabyte scanned during a query, unoptimized wildcard queries across long time horizons can rack up massive bills on high-throughput clusters. Follow these architectural query rules:

  • Narrow Time Range Windows: Always restrict query intervals to the specific 15-minute incident window rather than selecting default 24-hour or 7-day presets. Scanning 500 GB across 7 days costs $2.50 per click.
  • Filter Before Parsing: Place filter @message like /error/ ahead of field extractions. CloudWatch Log Insights prunes non-matching chunks before running expensive JSON or regular expression parsing.
  • Pre-Parse Fields in JSON: Ensure microservice logs are emitted as single-line JSON structures. CloudWatch automatically maps JSON keys into @message attributes, eliminating regex CPU scanning overhead.
  • Leverage Ephemeral Log Groups for Ephemeral CI/CD Runners: Never stream GitHub Actions, GitLab CI, or ephemeral testing container logs to production log groups. Use dedicated scratch log groups with a 24-hour retention ceiling.

Frequently Asked Questions: AWS CloudWatch Cost Optimization

Why is AWS CloudWatch log ingestion billed at $0.50/GB while S3 storage is only $0.023/GB?

CloudWatch ingestion is a fully managed ingestion and real-time indexing pipeline. AWS automatically replicates log events across multiple availability zones, extracts standard metrics, maintains indexed search pointers, and supports real-time subscription filters (Kinesis, Lambda). While powerful, this managed processing creates a 20x price premium compared to raw S3 object storage.

What is the difference between OpenObserve and SigNoz for self-hosted observability?

OpenObserve is authored in Rust and designed to run natively on top of object storage (AWS S3, MinIO, Google Cloud Storage) using columnar Apache Parquet. It achieves 10x to 14x compression with virtually zero disk management overhead. SigNoz is an OpenTelemetry-native platform built on ClickHouse, offering blazing-fast SQL query execution and unified distributed tracing, metrics, and logs, but requires dedicated block storage (EBS) management.

How does CloudWatch Logs Infrequent Access (IA) compare to standard log classes?

AWS CloudWatch Logs Infrequent Access (IA) reduces ingestion fees by 50% ($0.25/GB compared to $0.50/GB standard). However, the IA class disables subscription filters, metric filters, anomaly detection, and embedded metric format (EMF). It is suited for cold diagnostic logs that are rarely queried and never trigger automated alarms.

Can I forward logs directly from AWS Lambda to S3 without CloudWatch?

Yes. By using AWS Lambda Telemetry API Extensions (such as the Vector Lambda Extension or AWS Distro for OpenTelemetry Lambda Layer), function execution logs can be intercepted and shipped directly to an S3 bucket or external observability collector over HTTP, bypassing CloudWatch Logs ingestion fees completely.