1. Compute Boundaries     — concurrency limits, scaling behavior, throttle response
2. Data Contracts         — schema validation, idempotency, ordering guarantees
3. Failure Envelopes      — DLQ coverage, retry policies, blast radius isolation
4. Observability Baseline — three-signal coverage, correlation IDs, alarm set
5. Cost Models            — unit economics per service, anti-pattern identification

// ✅ Compute boundary configuration template
const criticalFn = new Function(this, 'PaymentProcessor', {
  timeout: Duration.seconds(30),          // Timeout set explicitly — never default 3s
  memorySize: 1024,                        // Set from Power Tuning output, not guessed
  reservedConcurrentExecutions: 200,       // Guarantee + cap; never 'undefined'
  environment: { POWERTOOLS_SERVICE_NAME: 'payment-service' },
})

// Provisioned Concurrency via alias for P99 SLA
const prodAlias = criticalFn.addAlias('prod')
prodAlias.addAutoScaling({
  minCapacity: 5,
  maxCapacity: 50,
}).scaleOnUtilization({ utilizationTarget: 0.75 })

// ✅ Idempotency pattern: Powertools Idempotency on handler
import { makeHandlerIdempotent } from '@aws-lambda-powertools/idempotency'
import { DynamoDBPersistenceLayer } from '@aws-lambda-powertools/idempotency/dynamodb'

const persistenceStore = new DynamoDBPersistenceLayer({
  tableName: 'IdempotencyStore',
  keyAttr: 'id',
})

export const handler = makeHandlerIdempotent(
  async (event: AWSLambda.SQSEvent) => {
    // Idempotency is per-SQS message ID by default
    // Re-invocation with same event → returns cached result without re-executing
    return processOrder(event.Records[0])
  },
  { persistenceStore, config: { expiresAfterSeconds: 3600 } }
)

// ✅ Complete failure envelope template
const fn = new Function(this, 'Fn', { /* ... */ })
const asyncDlq = new Queue(this, 'AsyncDLQ')
const sqsDlq = new Queue(this, 'SQSDLQ')

// Async invocation failure capture
fn.configureAsyncInvoke({
  onFailure: new SqsDestination(asyncDlq),
  maxEventAge: Duration.hours(1),
  retryAttempts: 2,
})

// DLQ alarm — zero tolerance
new Alarm(this, 'AsyncDLQAlarm', {
  metric: asyncDlq.metricApproximateNumberOfMessagesVisible({ period: Duration.minutes(1) }),
  threshold: 0,
  evaluationPeriods: 1,
  alarmDescription: `${fn.functionName} async failures captured — requires investigation and redrive`,
})

// ✅ Service-level CloudWatch Dashboard — one per service, all signals
import { Dashboard, GraphWidget, SingleValueWidget } from 'aws-cdk-lib/aws-cloudwatch'

new Dashboard(this, 'OrderServiceDashboard', {
  dashboardName: 'order-service-production',
  widgets: [
    [
      new GraphWidget({ title: 'Error Rate (%)', left: [/* errorRate metric */], width: 12 }),
      new GraphWidget({ title: 'P99 Duration (ms)', left: [/* p99 metric */], width: 12 }),
    ],
    [
      new GraphWidget({ title: 'Concurrent Executions', left: [/* concurrency metric */], width: 8 }),
      new GraphWidget({ title: 'Throttles', left: [/* throttle metric */], width: 8 }),
      new SingleValueWidget({ title: 'DLQ Depth', metrics: [dlqDepth], width: 8 }),
    ],
  ]
})

"My function works" ←  mid-level completion criterion

"My function participates correctly in a distributed system
  under partial failure:    Does every failure path have a capture mechanism?
  at peak load:            Does every resource have a capacity boundary?
  after a deployment:      Does every write path have idempotency?
  on retry:                Does every retry produce the same observable state?
  under noisy neighbors:   Is every critical-path function isolated from the shared pool?"