Serverless Architecture Pattern

Help me design a serverless architecture for my application with these requirements:

Application Type: [WEB APP/API/DATA PROCESSING/IOT/EVENT-DRIVEN]
Expected Traffic Pattern: [STEADY/BURSTY/SEASONAL/UNPREDICTABLE]
Target Cloud: [AWS/GCP/AZURE]
Performance Requirements: [LATENCY/THROUGHPUT TARGETS]
Data Storage Needs: [RELATIONAL/NOSQL/FILES/TIME-SERIES]
Integration Requirements: [THIRD-PARTY APIS/LEGACY SYSTEMS]

Design the serverless architecture covering these six components:

1. Compute Layer Design
- Select the appropriate serverless compute services such as Lambda, Cloud Functions, or Azure Functions. Define function granularity and the single-responsibility principle for each function. Design function packaging, layers, and shared dependency management. Plan for cold start mitigation strategies including provisioned concurrency, function warming, and architecture choices. Set memory and timeout configurations based on workload profiles. Address function composition patterns using step functions, orchestration, and choreography. Define concurrency limits and throttling strategies.

2. API and Event Layer
- Design the API layer using API Gateway, Cloud Endpoints, or Azure API Management. Define REST and GraphQL endpoint structures with request validation and transformation. Configure authentication and authorization flows using JWT, OAuth, and API keys. Design event-driven patterns using SNS, SQS, EventBridge, or Pub/Sub for asynchronous processing. Implement event filtering, dead letter queues, and retry policies. Plan for webhook handling and external event ingestion.

3. Data Layer Architecture
- Select serverless database options such as DynamoDB, Firestore, Cosmos DB, or Aurora Serverless. Design data access patterns optimized for serverless constraints like connection pooling and stateless access. Implement caching strategies with ElastiCache Serverless, Momento, or application-level caching. Plan for data consistency models including eventual consistency and strong consistency tradeoffs. Design file and object storage using S3, Cloud Storage, or Blob Storage with event triggers. Address search requirements using managed services like OpenSearch Serverless.

4. Workflow and Orchestration
- Design complex workflows using Step Functions, Cloud Workflows, or Durable Functions. Implement saga patterns for distributed transactions across services. Define error handling, compensation logic, and rollback procedures. Plan for long-running processes and human approval steps. Design batch processing pipelines for large data sets. Implement fan-out and fan-in patterns for parallel processing.

5. Observability and Debugging
- Implement structured logging with correlation IDs across function invocations. Set up distributed tracing using X-Ray, Cloud Trace, or Application Insights. Design custom metrics and dashboards for serverless-specific concerns including cold starts, throttling, and duration. Configure alerting for error rates, latency breaches, and cost anomalies. Plan for local development and testing using SAM, Serverless Framework, or emulators. Address debugging challenges unique to serverless environments.

6. Security and Cost Management
- Apply least-privilege IAM roles per function. Implement VPC integration where necessary while managing cold start implications. Design secrets management using Secrets Manager or Parameter Store. Plan for input validation and injection prevention. Model costs based on invocation counts, duration, and data transfer. Implement cost controls including budget alerts, concurrency limits, and reserved concurrency. Compare serverless costs versus container or VM alternatives at projected scale.

For each component provide specific service selections with justification, configuration recommendations, code pattern examples in pseudocode, scaling behavior analysis, and cost estimation methodology.