Infrastructure cost tracking

typeof CostRecordSchema>;

export class InfrastructureCostTracker { private costExplorer: CostExplorerClient; private sqs: SQSClient; private baselineMap: Map<string, number> = new Map();

constructor(region: string, queueUrl: string) { this.costExplorer = new CostExplorerClient({ region }); this.sqs = new SQSClient({ region }); }

async fetchCurrentPeriodCosts(days: number = 1): Promise<CostRecord[]> { const endDate = new Date(); const startDate = new Date(); startDate.setDate(endDate.getDate() - days);

const command = new GetCostAndUsageCommand({
  TimePeriod: { Start: startDate.toISOString().split("T")[0], End: endDate.toISOString().split("T")[0] },
  Granularity: Granularity.DAILY,
  Metrics: ["BlendedCost"],
  GroupBy: [
    { Type: "DIMENSION", Key: "SERVICE" },
    { Type: "TAG", Key: "team" },
    { Type: "TAG", Key: "environment" }
  ]
});

const response = await this.costExplorer.send(command);
const results: CostRecord[] = [];

for (const group of response.ResultsByTime?.[0]?.Groups || []) {
  const service = group.Keys?.[0] || "unknown";
  const team = group.Keys?.[1] || "unassigned";
  const environment = group.Keys?.[2] || "unassigned";
  const cost = parseFloat(group.Metrics?.BlendedCost?.Amount || "0");
  const key = `${team}:${environment}:${service}`;

  const baseline = this.baselineMap.get(key) || cost;
  const delta = cost - baseline;
  const isAnomaly = Math.abs(delta / baseline) > 0.25; // 25% threshold

  this.baselineMap.set(key, baseline * 0.7 + cost * 0.3); // Exponential smoothing

  results.push({
    service,
    team,
    environment,
    cost,
    currency: "USD",
    timestamp: new Date().toISOString(),
    deltaFromBaseline: delta,
    isAnomaly
  });
}

return results;

}

async publishToQueue(records: CostRecord[]): Promise<void> { const payload = JSON.stringify(records); const command = new SendMessageCommand({ QueueUrl: process.env.COST_QUEUE_URL || "", MessageBody: payload, MessageGroupId: "cost-tracking" });

await this.sqs.send(command);

}

async runPipeline(): Promise<void> { const costs = await this.fetchCurrentPeriodCosts(); const anomalies = costs.filter(r => r.isAnomaly);

if (anomalies.length > 0) {
  await this.publishToQueue(anomalies);
  console.log(`[CostTracker] ${anomalies.length} anomalies published to queue`);
}

} }

The processor uses exponential smoothing to maintain a dynamic baseline per team/service/environment combination. The 25% delta threshold isolates genuine cost spikes from predictable scaling. Records are validated against a Zod schema before queue publication, ensuring downstream consumers never encounter malformed billing data.

## Pitfall Guide

1. **Relying Solely on Provider Billing Dashboards**
   Provider consoles aggregate data at the account level and lack engineering context. They cannot correlate cost with deployment events, making root-cause analysis impossible. Always ingest raw billing exports into your own data layer.

2. **Inconsistent or Missing Cost-Allocation Tags**
   Without mandatory tags, cost attribution collapses into guesswork. Teams will default to `unassigned` buckets, masking waste. Enforce tags via policy-as-Code and block provisioning when required keys are absent.

3. **Ignoring Reserved Instance & Savings Plan Utilization**
   Purchasing RIs/SPs without tracking utilization creates phantom savings. Underutilized commitments still incur charges. Track coverage ratios and alert when utilization drops below 80%.

4. **Overlooking Data Egress & Cross-Region Transfer Costs**
   Compute costs are visible; network costs are not. Misconfigured replication, backup jobs, or CDN misrouting can spike egress fees silently. Monitor `DataTransfer-Out-Bytes` metrics alongside compute spend.

5. **Static Budget Thresholds Instead of Dynamic Baselines**
   Fixed alerts generate fatigue. A 10% increase during peak season is normal; a 10% increase during idle hours is not. Use rolling averages or exponential smoothing to establish context-aware thresholds.

6. **Treating Cost Tracking as a Post-Deployment Task**
   Optimization delayed is optimization lost. Integrate cost checks into CI/CD pipelines. Fail deployments that exceed projected cost deltas or violate tag policies before resources provision.

7. **Not Correlating Cost with Business Metrics**
   Tracking raw spend without context leads to blanket cuts. Map cost to business units: cost per request, cost per active user, cost per transaction. This shifts the conversation from "reduce spend" to "optimize efficiency."

**Best Practices from Production:**
- Implement tag compliance gates in Terraform/Pulumi using `required_tags` validation.
- Schedule cost pipeline runs at 15-minute intervals during active deployment windows, hourly during stable periods.
- Store raw billing exports in cold storage for audit reconciliation; keep normalized aggregates in hot storage for querying.
- Rotate API credentials via IAM roles; never embed access keys in pipeline configurations.
- Run monthly RI/SP coverage audits and automate expiration alerts 30 days prior.

## Production Bundle

### Action Checklist
- [ ] Define mandatory cost-allocation tags (`team`, `environment`, `service`, `cost-center`) and enforce via policy-as-Code
- [ ] Provision a dedicated cost tracking account or organizational unit to isolate billing data
- [ ] Implement event-driven ingestion pipeline (SNS/SQS, Pub/Sub, or EventBridge) for billing exports
- [ ] Deploy TypeScript cost normalizer with exponential baseline smoothing and schema validation
- [ ] Configure dynamic anomaly thresholds (20-30% delta from 7-day rolling average)
- [ ] Map cost records to business metrics (cost per request, cost per active deployment)
- [ ] Schedule monthly RI/SP utilization audits and automated expiration alerts
- [ ] Integrate cost validation gates into CI/CD pipelines to block untagged or over-budget deployments

### Decision Matrix

| Scenario | Recommended Approach | Why | Cost Impact |
|----------|---------------------|-----|-------------|
| Startup (<$50k/mo) | Tag-based monthly aggregation + provider console | Low engineering overhead; sufficient for early-stage visibility | 15-20% waste reduction |
| Mid-Market ($50k-$500k/mo) | Event-driven pipeline + PostgreSQL + dynamic baselines | Scales with deployment frequency; enables team-level attribution | 35-45% waste reduction |
| Enterprise Multi-Cloud | Unified cost normalizer + ClickHouse + policy-as-Code enforcement | Cross-provider schema alignment; centralized governance | 45-60% waste reduction |
| Compliance-Heavy (SOC2/ISO) | Immutable billing exports + audit trails + automated tag validation | Meets audit requirements; prevents untagged resource drift | 25-30% waste reduction + compliance assurance |

### Configuration Template

```typescript
// cost-tracker.config.ts
import { z } from "zod";

export const CostTrackerConfigSchema = z.object({
  awsRegion: z.string().default("us-east-1"),
  costQueueUrl: z.string().url(),
  baselineSmoothingFactor: z.number().min(0.1).max(0.9).default(0.3),
  anomalyThresholdPercent: z.number().min(10).max(50).default(25),
  requiredTags: z.array(z.string()).min(3).default(["team", "environment", "service"]),
  ingestionIntervalMinutes: z.number().min(5).max(60).default(15),
  alertWebhookUrl: z.string().url().optional(),
  storageProvider: z.enum(["postgresql", "clickhouse", "dynamodb"]).default("postgresql")
});

export type CostTrackerConfig = z.infer<typeof CostTrackerConfigSchema>;

export const defaultConfig: CostTrackerConfig = {
  awsRegion: process.env.AWS_REGION || "us-east-1",
  costQueueUrl: process.env.COST_QUEUE_URL || "",
  baselineSmoothingFactor: 0.3,
  anomalyThresholdPercent: 25,
  requiredTags: ["team", "environment", "service"],
  ingestionIntervalMinutes: 15,
  alertWebhookUrl: process.env.SLACK_WEBHOOK_URL,
  storageProvider: "postgresql"
};

Quick Start Guide

1. Deploy Policy Enforcement: Add a Conftest/OPA policy to your CI pipeline that validates team, environment, and service tags on all Terraform/Pulumi plans. Fail builds missing required keys.
2. Provision Ingestion Queue: Create an SQS/SNS topic or cloud-native event stream. Attach an IAM role with costexplorer:GetCostAndUsage and sqs:SendMessage permissions.
3. Run Cost Normalizer: Deploy the TypeScript processor as a Lambda or containerized service. Configure environment variables for queue URL, region, and threshold parameters. Trigger via EventBridge schedule (every 15 minutes).
4. Validate & Alert: Verify normalized records in your storage layer. Configure a webhook consumer to parse anomaly payloads and route to Slack/PagerDuty. Confirm delta calculations align with deployment events.
5. Monitor & Tune: Review baseline smoothing accuracy after 7 days. Adjust threshold percentages based on deployment cadence. Schedule monthly RI/SP coverage checks.