FinOps and Budget Management

Brief Summary

1. we measure the value and cost of a unit (unit-economics),

2. we put budgets and guardrails,

3. predict demand and plan capacity,

4. Manage purchases/discounts

5. changing architecture and processes for the sake of SLO with minimal TCO.

Roles and responsibilities

Product/Business: revenue targets/MAU/LTV, budget limits.
FinOps: methodology, reporting, procurement, budget signals.
Engineering/SRE: rightsizing, scaling, cache/architecture, operational levers.
Data/Analytics: load and cost forecast, anomalies.
Security/Compliance: storage/log/DR requirements affecting TCO.

RACI: FinOps manages processes and reports → engineers implement cost-effective changes → business approves budgets/priorities.

Metrics and unit-economics

$/1000 RPS (or $/1k events/transactions) - basic service cost metric.
$/ms p95 - how much does the latency tail shift cost (important for conversion).
$/MAU, $/deposit, $/player/month - business units.
TCO = compute + storage + network egress + managed services + licenses + labor.
Cost Coverage Ratio: the share of "closed" on-demand consumption by commit plans.

Example: the service gives 60k RPS at $120/h → $2/1000 RPS· h. Any optimization is compared to this benchmark.

Tagging and Transparency

Required tags: 'env', 'product', 'service', 'owner', 'region', 'tier', 'cost-center'.
Without tags - we do not create or extend resources.

Showback/Chargeback: Weekly team/product reports tied to unit metrics.
Anomalies: daily deltas> X% and "dumb" resources (0 RPS, there is a cost).

Budgets, guardrails and alerts

Monthly budget by service/product + soft/hard guardrails.

• daily burn-rate> × plan (days in the month/remaining days),
• egress/log-ingest> thresholds,
• spot preemption> N% of time,
• the growth of "draw" resources.
• Policies: prohibition of resources without tags, auto-TTL staging, storage class limits.

Cost forecasting

1. Drivers: MAU, DAU, RPS by route, cache share, seasonality/events.
2. Model: baseline trend + seasonality + scenarios (baseline/aggressive).
3. Money transfer: consumption profiles by layers (edge/proxy/app/DB/logging).
4. Lay steps: headroom 30% for peaks, reserve for DR/commit plans.

Cost_month ≈ Σ (RPS_route × $/1kRPS_route × часы) + egress + storage + managed

Purchasing and consumption patterns

Reserved/Savings/Committed Use (1-3 years) - close a stable base (saving 30-70%).
Spot/Preemptible - CI/analytics/asynchron, data pipelines.
Mix: base - commit, peaks - on-demand, background/background - spot.
Rule 70/20/10: 70% - commit, 20% - on-demand elastic, 10% - spot.

Engineering savings levers (no SLO loss)

Rightsizing: CPU operating point 50-70%, VPA recommendations, small instances fit better.
Auto-scaling for SLO: HPA/KEDA by latency/lag/RPS, not just CPU.
Cache and CDN: cache key without "noise," TTL-stairs, tiered-cache/origin-shield → egress↓, DB↓.
Network: Brotli/gzip, webp/avif, diff-API, keepalive, retray-budget.
Storage: classes (hot/warm/cold), lifecycle-policies, TTL per time data.
Logs/metrics/trails: sampling, tail-based, storage high-res 7-14 days.
Architecture: gRPC/protocol between services, batch/stream instead of chats, selection of a database by profile (KV for frequent reads).

Cost of reliability and DR

RTO/RPO → value: asset-asset vs asset-liability, cold backups.
Calculation: how much does a minute of downtime cost vs how much does an additional replica/region cost.

Policy: "pay for reliability if it pays off with risk."

FinOps dashboards (minimum set)

1. Cost Overview: by products/services/regions, trends, forecast until the end of the month.
2. Unit-economics: $/1k RPS, $/ms p95, $/MAU (by week).
3. Egress/Storage: egress GB/$, distribution of storage classes.
4. Logging/Observability: ingest by source,% of useful logs, cost of p99 tails.
5. Commit Coverage: share of closed consumption, risk of underutilization.
6. Anomalies: top spikes and "dumb" resources.

Processes and rituals

Weekly FinOps: top 10 leaks, owner → action → ETA.
Monthly Cost Review: Fact vs Budget, Procurement Efficiency, Commits Review.
Pre-event Review: plan of peaks (min-replicas, warm-pools, cache, PSP limits).
Blameless post-sea on price incidents (leak logs, runaway autoscale).

Implementation checklist

• Tagging is strict, showback/chargeback by command.
• Unit metrics defined ($/1k RPS, $/ms p95, $/MAU).
• Budgets/guardrails/alerts are set up.
• Cost forecast is related to traffic forecast and SLO.
• The commit plans and the spot/on-demand portfolio are balanced.
• Rightsizing and SLO scaling included (HPA/KEDA/VPA/CA).
• Cache/CDN/egress optimized, lifecycle on storage.
• Logs/Metrics/Traces - Sampling and TTL.
• DR policy on RTO/RPO and its cost are fixed.
• Weekly and monthly reviews work.

Common errors

There is no unit-economics → we argue "on sensations."

Resources without tags, "draw" environments live for months.
Storage of everything in a hot classroom without lifecycle.
Logs as a "black hole" - 100% ingest, 5% reads.
Commit to "everything" → underutilization and fines.
Auto-scale on CPU excluding latency/lag → overpayment or SLO failure.
Oversupplied DR without business justification.

Mini playbooks

1) Fast "three-day" FinOps audit

1. Cut the top 10 services and egress. 2) Enable lifecycle on "old" objects.
2. Cut noisy logs/enable tail-based. 4) Introduce TTL staging/previews.
3. Fix $/1k RPS and targets at a − of 15 %/month.

2) − 25% egress for the week

1. Tiered-cache + origin-shield. 2) Translation of pictures into webp/avif.
2. Diff-API and Brotli. 4) Reduce retry-rate and enable request-collapsing.

3) "runaway autoscale" attack

1. Increase stabilization/cooldown, minReplicas at peak.
2. Move part of the background to spot and batch windows.
3. Warm up images (image pre-pull) and TLS/connections.

4) Underutilization of commits

1. Rebuild the portfolio, transfer part of the on-demand to commit.
2. Migrate suitable workloads to ARM/other type.
3. Enable auto-parking during off hours.

Examples of artifacts

sql
SELECT product, service, date_trunc('week', usage_date) AS wk,
SUM(cost_usd) AS cost, SUM(rps) AS rps,
ROUND(SUM(cost_usd) / NULLIF(SUM(rps)/1000,0), 3) AS usd_per_1k_rps
FROM finops_daily
GROUP BY 1,2,3
ORDER BY 3 DESC;

rego package finops deny[msg] {
input. resource. tags. owner == ""
msg:= "resource without owner tag"
}
deny[msg] {
input. resource. env == "dev"
input. resource. ttl == ""
msg:= "dev resource without TTL"
}

iGaming/fintech specific

Peaks (matches/tournaments): raise minReplicas/minNodes in advance, warm up CDN/TLS/caches, gray routes for bots; headroom dot on hot endpoints (lobby/catalogs/match feeds).
Payments/PSP: accounting for quotas/values ​ ​ by providers, a separate egress pool and idempotency → fewer takes.
Antifraud/AML: multi-stage check (cheap gray check on the edge → expensive scoring only if necessary).
Content providers: CDN cache, update frequency limits, revision of contracts for large events.

Total

Effective FinOps is not about "cutting costs," but managing them in conjunction with product speed and SLO.
Keep unit costs transparent, build budgets and guardrails, combine procurement with engineering leverage, automate savings and regularly do cost reviews. So the platform will remain fast, sustainable and profitable - even at peak growth.