gh-adrianpuiu-claude-skills…/references/domain-templates.md

# Domain-Specific Templates Reference

This reference provides specialized templates and patterns for different types of systems.

## Table of Contents

- [Trading and Financial Systems](#trading-and-financial-systems)
- [Real-time Systems](#real-time-systems)
- [E-commerce](#e-commerce)
- [Content Management Systems](#content-management-systems)
- [IoT](#iot)
- [Machine Learning Pipelines](#machine-learning-pipelines)
- [Developer Tools](#developer-tools)
- [SaaS](#saas)
- [Data Lakehouse and Analytics Systems](#data-lakehouse-and-analytics-systems)
- [AI Agent and Orchestration Systems](#ai-agent-and-orchestration-systems)
- [Enterprise Integration Platforms](#enterprise-integration-platforms)
- [Common Non-Functional Requirements](#common-non-functional-requirements)
- [Cross-Cutting Concerns](#cross-cutting-concerns)
- [Task Breakdown Patterns by Domain](#task-breakdown-patterns-by-domain)
- [Testing Strategies by Domain](#testing-strategies-by-domain)
- [Deployment Patterns](#deployment-patterns)

## Trading and Financial Systems

### Specific Requirements Patterns

```markdown
### Market Data Requirements
- THE system SHALL process market data streams and orders with sub-millisecond latency.
- THE system SHALL integrate with external financial exchanges and market data feeds using standard protocols (e.g. FIX, REST APIs).
- THE system SHALL support large volumes of transactions concurrently (thousands to millions per second).
- THE system SHALL provide time synchronization mechanisms for ordering of events across components.

### Risk Management Requirements
- THE system SHALL include real-time risk management to reject or flag risky orders based on configurable rules.
- THE system SHALL log all transactions and data changes for auditing and traceability.
- THE system SHALL generate regulatory reports (e.g. trade confirmations, position reports) in required formats on scheduled intervals.
- THE system SHALL ensure ACID compliance for financial transactions to maintain consistency.

### Order Execution Requirements
- THE system SHALL support connection to trading user interfaces and algorithmic trading bots through well-defined APIs.
- THE system SHALL provide high availability (99.999%) with active-active clustering and automated failover.
- THE system SHALL implement stringent security controls, encryption in transit and at rest, and authentication/authorization for all components.
```

### Architecture Components

```markdown
### Market Data Ingestion
- Captures real-time price feeds from exchanges and data vendors.
- Protocol adapters (e.g. FIX engines, API gateways) for external integration.
- Network optimization for low-latency data delivery.

### Order Entry Gateway
- Receives and validates incoming orders from trading applications or clients.
- Authentication and authorization of trading requests.
- Order validation and pre-trade risk checks.

### Order Matching Engine
- Matches buy and sell orders in an order book and confirms trades.
- High-performance order book management.
- Trade execution and confirmation logic.

### Risk Management Service
- Evaluates orders and positions against risk rules (e.g. credit limits, market risk).
- Real-time position monitoring and limit checking.
- Risk alert generation and order rejection.

### Trade Repository
- Stores executed trades, order history, and market data for reconciliation and analytics.
- Audit trail maintenance for regulatory compliance.
- Historical data storage and retrieval.

### Settlement and Clearing Module
- Handles post-trade processing, settlements with clearing houses, and ledger updates.
- Trade confirmation and settlement workflows.
- Financial ledger management.

### User Interface
- Web/mobile applications or trader workstations for order entry and monitoring.
- Real-time market data visualization.
- Trading dashboard and analytics.

### Security Layer
- Infrastructure for encryption, secure network zones, identity management, and audit logging.
- Network segmentation and access controls.
- Security monitoring and incident response.

### Analytics Engine
- Provides real-time analytics, reporting, and historical trend analysis for traders and compliance teams.
- Performance metrics calculation.
- Custom report generation.
```

## Real-time Systems

### Specific Requirements Patterns

```markdown
### Event Processing
- THE system SHALL process and respond to incoming events within a defined real-time threshold (e.g. milliseconds to seconds) to meet business needs.
- THE system SHALL support streaming data ingestion and event processing at high throughput (e.g. thousands of events per second).
- THE system SHALL guarantee the order of events when required (in-order processing).
- THE system SHALL maintain state consistency across distributed components for stateful real-time operations.

### Reliability and Scaling
- THE system SHALL be resilient to failures and able to recover quickly without data loss.
- THE system SHALL provide real-time monitoring and alerting on processing delays and system health.
- THE system SHALL support horizontal scaling to meet increasing volumes of events.
- THE system SHALL provide time synchronization mechanisms (e.g. NTP or PTP) for ordering of events across components.

### Integration and Security
- THE system SHALL integrate with real-time analytics and dashboarding tools to display live data.
- THE system SHALL include security measures for data in transit and at rest, as real-time systems often handle sensitive data.
```

### Architecture Components

```markdown
### Event Sources
- Sensors, user interfaces, or external services generating real-time events.
- Event format standardization.
- Source authentication and validation.

### Ingestion Layer (Message Broker)
- High-throughput messaging system (e.g. Apache Kafka, RabbitMQ) to buffer and distribute events.
- Message partitioning and routing.
- Durability and replay capabilities.

### Stream Processing Engine
- Processes streams in real time (e.g. Apache Flink, Spark Streaming, or microservices) performing filtering, aggregation, and event correlation.
- State management for stream operations.
- Windowing and time-based operations.

### State Store
- Distributed in-memory or fast storage (e.g. Redis, Cassandra) to maintain application state for stream processing.
- State backup and recovery.
- Consistent state across processing nodes.

### Real-time Databases
- Databases optimized for real-time read/write (e.g. in-memory DBs) for low-latency queries.
- Data indexing for fast access.
- Query optimization for real-time workloads.

### API Gateway/WebSockets
- Interfaces to push real-time updates to clients (web/mobile) via WebSockets or Server-Sent Events.
- Connection management and authentication.
- Message routing to clients.

### Monitoring & Alerting
- Systems (e.g. Prometheus, Grafana) to track latency, throughput, and health of components.
- Real-time dashboard creation.
- Alert configuration and notification.

### Configuration Service
- Centralized service to manage and distribute real-time system configurations and thresholds.
- Dynamic configuration updates.
- Environment-specific settings management.

### Security Layer
- Encryption and authentication for data sources, brokers, and processing nodes.
- Access control for event streams.
- Security monitoring for real-time systems.

### Scalable Compute Cluster
- Container orchestration (e.g. Kubernetes) or real-time optimized servers to manage deployment of processing services.
- Resource allocation and scaling.
- Load balancing for processing nodes.
```

## E-commerce

### Specific Requirements Patterns

```markdown
### Product Catalog
- THE system SHALL support a large catalog of products and enable fast search and filtering.
- THE system SHALL implement caching (e.g. CDN, distributed cache) to accelerate delivery of static assets and frequently accessed data.
- THE system SHALL support personalization features, such as product recommendations and targeted promotions.
- THE system SHALL provide analytics and reporting on sales, traffic, and user behavior.

### Shopping Cart and Checkout
- THE system SHALL allow users to browse products, add items to a shopping cart, and proceed through a checkout process seamlessly.
- THE system SHALL integrate securely with multiple payment gateways (e.g. credit card, digital wallets) to process orders.
- THE system SHALL maintain inventory counts and prevent overselling by updating stock in real-time during purchases.
- THE system SHALL ensure high availability and scalability to handle peak loads (e.g. sales events).

### User Management
- THE system SHALL provide a secure user account management for registration, login, and profile management.
- THE system SHALL support order tracking and status updates for customers and administrators.
```

### Architecture Components

```markdown
### Web and Mobile Frontend
- Customer-facing applications (websites or mobile apps) presenting product catalogs and user interfaces.
- Responsive design for multiple devices.
- Progressive web app capabilities.

### API Gateway
- Secure entry point for client applications to interact with backend services.
- Rate limiting and request validation.
- API versioning and documentation.

### Product Catalog Service
- Manages product data, categories, pricing, and availability.
- Search and filtering functionality.
- Product recommendation engine.

### Shopping Cart Service
- Maintains user cart state and manages cart operations.
- Session management for anonymous and logged-in users.
- Cart persistence across sessions.

### Order Management Service
- Orchestrates order placement, validation, and status tracking.
- Order workflow automation.
- Integration with fulfillment systems.

### Inventory Service
- Tracks stock levels across warehouses and updates quantities.
- Inventory reservation during checkout.
- Low stock alerts and reordering.

### Payment Service
- Handles payment processing through integration with external payment gateways.
- Payment method tokenization.
- Transaction reconciliation and dispute handling.

### User Management Service
- Manages user authentication, authorization, and profiles (can integrate with Identity provider).
- Social login integration.
- User preference and history tracking.

### Search and Recommendation Engine
- Provides full-text search and personalized product recommendations (e.g. Elasticsearch, Machine Learning).
- Search analytics and optimization.
- Recommendation algorithm tuning.

### Content Delivery Network (CDN)
- Distributes static content (images, scripts, CSS) globally for fast access.
- Edge caching and optimization.
- Dynamic content acceleration.

### Analytics and Reporting
- Aggregates sales, customer behavior, and performance data for dashboards.
- Business intelligence and insights.
- Custom report generation.

### Logging and Monitoring Tools
- Tracks system health, errors, and performance (e.g. ELK stack, Prometheus).
- Application performance monitoring.
- Error tracking and alerting.
```

## Content Management Systems

### Specific Requirements Patterns

```markdown
### Content Creation and Management
- THE system SHALL allow content authors to create, edit, and schedule publishing of content with version control.
- THE system SHALL support multiple content types (text, images, video, documents, etc.) and metadata for each content item.
- THE system SHALL provide a user-friendly content editor interface (WYSIWYG or markdown) and workflows for review/approval.

### Content Delivery
- THE system SHALL deliver content via APIs or templates to multiple channels (web, mobile, social).
- THE system SHALL implement role-based access control so that only authorized users can publish or modify content.
- THE system SHALL support full-text search and indexing of content for fast retrieval.

### Performance and Reliability
- THE system SHALL allow for content preview in different templates or layouts before publishing.
- THE system SHALL integrate a caching layer (e.g. CDN, reverse proxy) to improve performance of content delivery.
- THE system SHALL provide audit logs of content changes for accountability.
- THE system SHALL ensure high availability to avoid content downtime.
```

### Architecture Components

```markdown
### Content Repository
- Central database or storage (e.g. MySQL, MongoDB, Blob storage) that stores content and metadata.
- Content versioning and history tracking.
- Binary asset management.

### Authoring Interface
- Web-based UI for content creators to author, edit, and manage content.
- Rich text editor and media management.
- Collaboration features for content teams.

### Delivery API
- REST or GraphQL APIs that serve content to front-end applications.
- Content transformation and formatting.
- API access controls and rate limiting.

### Front-end Delivery Layer
- Rendered website or mobile app that displays the content to end-users.
- Template engine integration.
- Multi-channel content adaptation.

### Template Engine
- (if not headless) Generates HTML views from content and templates.
- Template inheritance and composition.
- Dynamic content rendering.

### Search Index
- Engine (e.g. Elasticsearch) that indexes content for search queries.
- Full-text search capabilities.
- Search relevance optimization.

### Cache/CDN
- Caching proxy or content delivery network to store and serve static content and pages.
- Cache invalidation strategies.
- Performance optimization.

### Workflow Engine
- Manages content publishing workflows (draft, review, publish states).
- Approval process configuration.
- Notification and escalation rules.

### Authentication/Authorization Service
- Manages user identities, roles, and permissions.
- Integration with enterprise identity systems.
- Fine-grained access control.

### Analytics Dashboard
- Tracks content performance (views, engagement) and provides reporting.
- User behavior analysis.
- Content effectiveness metrics.
```

## IoT

### Specific Requirements Patterns

```markdown
### Device Management
- THE system SHALL support secure onboarding and provisioning of a large number of IoT devices.
- THE system SHALL allow over-the-air (OTA) firmware or configuration updates to devices.
- THE system SHALL implement device identity management and authentication to prevent unauthorized devices.
- THE system SHALL scale horizontally to support millions of concurrent device connections.

### Data Ingestion and Processing
- THE system SHALL use lightweight protocols (e.g. MQTT, CoAP) to handle unreliable networks and constrained devices.
- THE system SHALL ingest telemetry data from devices at high volume and in near-real-time.
- THE system SHALL provide mechanisms for batching or edge processing to reduce cloud communication costs.
- THE system SHALL ensure data durability by storing raw telemetry in a fault-tolerant data lake or time-series database.

### Monitoring and Security
- THE system SHALL enable real-time monitoring and alerts based on streaming data (e.g. temperature thresholds).
- THE system SHALL comply with security standards (e.g. encryption of data in transit and at rest, secure key storage).
```

### Architecture Components

```markdown
### Edge or Gateway Services
- Local bridges or gateways that aggregate device connections and preprocess data.
- Protocol translation and normalization.
- Local data processing and filtering.

### Device Registry
- Catalog of devices and metadata for management and authentication.
- Device lifecycle management.
- Device grouping and organization.

### Message Broker/Hub
- Middleware (e.g. AWS IoT Core, Azure IoT Hub, MQTT broker) to receive and route device telemetry.
- Message filtering and routing rules.
- Quality of service management.

### Stream Ingestion Service
- Processes incoming data streams for real-time handling (e.g. AWS Kinesis, Azure Event Hubs).
- Data validation and enrichment.
- Stream partitioning and scaling.

### Data Processing/Analytics
- Real-time (e.g. stream analytics) and batch processing for insights (e.g. Spark, Flink).
- Anomaly detection and alerting.
- Data transformation and aggregation.

### Time-series Database/Data Lake
- Storage optimized for time-series data (e.g. InfluxDB, IoTDB) or scalable data lake (S3, HDFS).
- High-volume data retention.
- Efficient time-based queries.

### Device Management Service
- Handles OTA updates, configuration, and device health monitoring.
- Firmware deployment and rollback.
- Device diagnostics and troubleshooting.

### Security Service
- Certificate/key management for device authentication and encryption.
- Device identity verification.
- Security policy enforcement.

### Visualization/Dashboard
- Front-end or service to display device data and analytics.
- Real-time monitoring dashboards.
- Historical data visualization.

### Alerting & Notification
- Generates alerts/notifications (email, SMS, push) based on rules.
- Alert escalation policies.
- Notification history and tracking.
```

## Machine Learning Pipelines

### Specific Requirements Patterns

```markdown
### Data Pipeline
- THE system SHALL ingest and preprocess data from multiple sources (databases, logs, streams) into a central storage or data lake.
- THE system SHALL version control datasets, features, and models to ensure reproducibility.
- THE system SHALL include evaluation metrics tracking and validation steps in the pipeline.

### Model Training and Deployment
- THE system SHALL support scalable model training on large datasets using distributed compute (e.g. GPU clusters).
- THE system SHALL automate retraining of models on new data or when performance degrades.
- THE system SHALL support continuous deployment of validated models to production serving environments.
- THE system SHALL provide model serving endpoints (REST/gRPC) for inference with low latency.

### Monitoring and Governance
- THE system SHALL monitor model performance in production and trigger alerts on data drift or accuracy drop.
- THE system SHALL allow A/B testing of models and rollback to previous versions if needed.
- THE system SHALL ensure data privacy and compliance (e.g. anonymization, encryption) during processing and model training.
```

### Architecture Components

```markdown
### Data Ingestion Layer
- ETL pipelines (e.g. Apache NiFi, AWS Glue, Kafka Connect) to bring raw data into storage.
- Data validation and quality checks.
- Schema management and evolution.

### Data Storage
- Scalable data lake (e.g. S3, HDFS) or data warehouse for raw and processed data.
- Data partitioning and organization.
- Access controls and governance.

### Feature Store
- Centralized storage of engineered features for reuse in training and serving.
- Feature computation pipelines.
- Online and offline feature serving.

### Workflow Orchestration
- Pipeline management tools (e.g. Kubeflow Pipelines, Apache Airflow) to coordinate steps.
- Dependency management.
- Pipeline execution monitoring.

### Training Environment
- Compute cluster (e.g. Kubernetes with GPU nodes or Spark clusters) for model training.
- Distributed training frameworks.
- Resource optimization and scheduling.

### Model Registry
- Repository (e.g. MLflow, SageMaker Model Registry) to store and version trained models and metadata.
- Model lineage tracking.
- Model artifact storage.

### Model Serving Infrastructure
- Services or platforms (e.g. TensorFlow Serving, AWS SageMaker Endpoint) for online inference.
- Request routing and load balancing.
- Model version management.

### Monitoring and Logging
- Services to monitor pipeline runs, track metrics, logs (e.g. Prometheus, ELK, ML monitoring platforms).
- Performance metrics collection.
- Alert configuration and notification.

### Experimental Tracking
- Tools (e.g. MLflow Tracking) to log model parameters, metrics, and results.
- Experiment comparison.
- Hyperparameter optimization.

### Security and Compliance
- Data encryption services, access controls, and audit logs for the ML pipeline.
- Privacy-preserving ML techniques.
- Regulatory compliance tools.
```

## Developer Tools

### Specific Requirements Patterns

```markdown
### Version Control and Collaboration
- THE system SHALL provide a centralized version control repository (e.g. Git) for source code management.
- THE system SHALL facilitate collaboration features such as code reviews, merge requests, and documentation wikis.
- THE system SHALL include role-based access control to restrict who can merge or deploy code.

### CI/CD and Build Process
- THE system SHALL automate builds, tests, and deployments through CI/CD pipelines upon code commits or pull requests.
- THE system SHALL include a package or artifact repository (e.g. Nexus, Artifactory) to store build outputs.
- THE system SHALL enforce code quality checks (linting, static analysis, security scans) in the pipeline.

### Development Environment
- THE system SHALL offer environments (e.g. containers, VMs) that mimic production for testing and validation.
- THE system SHALL provide environment provisioning (infrastructure as code) to spin up test or staging environments on demand.
- THE system SHALL offer container and image registries for Docker or OCI artifacts.
```

### Architecture Components

```markdown
### Version Control System
- Git-based repository (e.g. GitLab, GitHub) for source code and branching.
- Code hosting and collaboration.
- Pull request workflow.

### CI/CD Platform
- Tools (e.g. Jenkins, GitHub Actions, GitLab CI) that define pipelines for build/test/deploy.
- Pipeline configuration and management.
- Build artifact storage.

### Artifact Repository
- Central storage (e.g. Nexus, Artifactory) for binaries and libraries.
- Dependency management.
- Version control for artifacts.

### Container Registry
- Storage for container images (e.g. Docker Hub, private registry).
- Image vulnerability scanning.
- Image promotion workflows.

### Issue Tracker / Project Management
- Tool (e.g. Jira, GitHub Issues) to track tasks and bugs.
- Project planning and tracking.
- Team collaboration features.

### Test Automation Framework
- Automated test suites (unit, integration, UI tests) integrated into CI.
- Test result reporting.
- Test environment provisioning.

### Infrastructure as Code
- Tools (e.g. Terraform, Ansible) to define and provision infrastructure.
- Environment configuration management.
- Infrastructure version control.

### Collaboration Platform
- Wiki or documentation site (e.g. Confluence, GitHub Pages) for team knowledge sharing.
- Documentation versioning.
- Knowledge base management.

### Security Scanning Tools
- Static code analysis, vulnerability scanning (e.g. SonarQube, Snyk).
- Security policy enforcement.
- Vulnerability management.

### Notification/ChatOps
- Integration with communication tools (e.g. Slack, Teams) for build/deploy notifications.
- Automated alerts and notifications.
- Chat-based operations.
```

## SaaS

### Specific Requirements Patterns

```markdown
### Tenant Management
- THE system SHALL support tenant isolation so that customer data is logically separated (e.g. separate databases or partitioned schema).
- THE system SHALL allow per-tenant configuration of features (feature flags or settings) without affecting others.
- THE system SHALL provide a self-service portal for onboarding new tenants and managing account settings.
- THE system SHALL include tenant-specific branding or theming if required.

### Subscription and Billing
- THE system SHALL implement subscription management and usage metering for billing.
- THE system SHALL scale resources (compute, storage) elastically based on overall usage across tenants.
- THE system SHALL ensure strict data security and privacy between tenants.

### Customization and Integration
- THE system SHALL support multi-region deployment for disaster recovery or latency requirements.
- THE system SHALL offer customization hooks (APIs or plugins) to allow integration with tenant systems.
- THE system SHALL provide centralized monitoring and logging across all tenants with filtering by tenant.
```

### Architecture Components

```markdown
### Tenant Management Service
- Manages tenant lifecycle (onboarding, offboarding, subscriptions).
- Tenant configuration management.
- Tenant billing and usage tracking.

### Authentication & Authorization
- Identity service (e.g. IAM) that supports multi-tenant logins (often through OAuth/OpenID).
- Single sign-on integration.
- Per-tenant access control.

### Multi-tenant Data Layer
- Databases or data warehouses with logical separation (schemas or tags) or separate instances per tenant.
- Data isolation strategies.
- Tenant-specific data optimization.

### Application Service
- The core application codebase, scaled horizontally (e.g. containerized services).
- Multi-tenant aware business logic.
- Tenant context management.

### Configuration Service
- Handles per-tenant configuration and feature toggles.
- Dynamic configuration updates.
- Tenant-specific settings management.

### Billing and Usage Service
- Tracks resource usage per tenant and generates billing records.
- Subscription management.
- Payment processing integration.

### Logging/Monitoring
- Centralized logging (e.g. ELK, Splunk) and monitoring (e.g. Prometheus) that isolates metrics per tenant.
- Tenant-specific dashboards.
- Cross-tenant analytics.

### API Gateway
- Routes tenant requests to appropriate services, often handling rate limiting and quotas per tenant.
- Tenant identification and routing.
- API access control per tenant.

### Self-Service Portal
- Web application or console where tenants manage their account and settings.
- Tenant onboarding workflow.
- Account management interface.

### Notification Service
- Sends emails or alerts to tenants for events like billing, outages, or updates.
- Tenant-specific notifications.
- Notification preference management.
```

## Data Lakehouse and Analytics Systems

### Specific Requirements Patterns

```markdown
### Data Storage and Management
- THE system SHALL store all raw and processed data in a centralized, scalable data lake (e.g. cloud object storage).
- THE system SHALL maintain a unified metadata catalog for datasets (data catalog) to enable discoverability.
- THE system SHALL support ACID transactions on data (e.g. through Delta Lake or Iceberg) for reliability.
- THE system SHALL automate data lifecycle management (e.g. partitioning, aging, archiving).

### Data Processing and Analytics
- THE system SHALL enable both batch and streaming ingestion pipelines for diverse data sources.
- THE system SHALL allow SQL-based analytics on data with low query latency (e.g. using a lakehouse query engine).
- THE system SHALL integrate with BI and visualization tools (e.g. Tableau, Power BI) for dashboards.
- THE system SHALL support large-scale machine learning directly on the lakehouse data.

### Governance and Security
- THE system SHALL implement data governance (data quality checks, access controls, lineage tracking).
- THE system SHALL provide role-based access control and encryption to secure sensitive data.
```

### Architecture Components

```markdown
### Data Ingestion Framework
- Tools (e.g. Apache NiFi, Kafka, AWS Glue) to bring batch and streaming data into the lakehouse.
- Data validation and quality checks.
- Schema detection and evolution.

### Data Lake Storage
- Scalable object storage (e.g. S3, ADLS) or distributed file system for raw and curated data.
- Data organization and partitioning.
- Storage optimization and tiering.

### Metadata Catalog
- Service (e.g. AWS Glue Catalog, Hive Metastore, Databricks Unity Catalog) that maintains schemas and table definitions.
- Data lineage tracking.
- Data discovery and documentation.

### Lakehouse Engine
- Query engines (e.g. Apache Spark, Trino/Presto, Databricks, Snowflake) that support ACID transactions and various workloads.
- Query optimization.
- Workload isolation.

### ETL/ELT Tools
- Platforms (e.g. dbt, Talend) to transform and load data into analytics-ready tables.
- Data transformation pipelines.
- Data quality monitoring.

### Data Warehouse Layer
- Structured tables optimized for BI (could be part of lakehouse or external warehouse).
- Aggregate table management.
- Performance optimization.

### Business Intelligence Tools
- Front-end tools (e.g. Tableau, Power BI) for dashboarding and reports.
- Self-service analytics.
- Interactive visualization.

### Streaming Analytics
- Components (e.g. Spark Streaming, Apache Flink) for real-time analytics on event streams.
- Stream processing logic.
- Real-time dashboard updates.

### Data Governance and Security
- Data quality tools, auditing, encryption, and IAM to manage policies.
- Data classification and tagging.
- Compliance reporting.

### Machine Learning Platform
- Integration (e.g. MLflow, AWS SageMaker) for training models on data lakehouse datasets.
- Feature engineering pipelines.
- Model deployment and monitoring.
```

## AI Agent and Orchestration Systems

### Specific Requirements Patterns

```markdown
### Agent Integration and Orchestration
- THE system SHALL allow modular integration of AI components (e.g. LLMs, vision models, NLP modules) into workflows.
- THE system SHALL orchestrate sequences of actions (prompt chains) among AI agents and external tools.
- THE system SHALL manage conversational or task state across multiple interactions and agents.
- THE system SHALL provide a mechanism for human-in-the-loop intervention or correction.

### Monitoring and Learning
- THE system SHALL log all AI queries and responses for auditing and iterative improvement.
- THE system SHALL monitor model performance in production and trigger alerts on data drift or accuracy drop.
- THE system SHALL enable continuous learning by feeding back usage data into retraining pipelines.
- THE system SHALL provide explainability logs or traces of decision paths taken by agents.

### Security and Scalability
- THE system SHALL secure integration with external data sources and APIs (e.g. databases, web APIs).
- THE system SHALL allow dynamic addition or removal of agents without downtime.
- THE system SHALL support parallel or ensemble execution of multiple AI models and combine results.
```

### Architecture Components

```markdown
### Agent Orchestrator
- Coordinates the workflow of multiple AI agents and tools (could be a custom microservice).
- Task scheduling and routing.
- Workflow definition and execution.

### Large Language Model API
- Connection to LLM services (e.g. OpenAI, Anthropic, local LLM cluster) for natural language tasks.
- Prompt engineering and management.
- Response parsing and validation.

### Specialized AI Modules
- Additional AI services (e.g. image recognition, speech-to-text, custom NLP models) for specific subtasks.
- Model hosting and serving.
- Model versioning and A/B testing.

### Conversation or State Manager
- Tracks the state of dialogs or multi-step tasks across interactions.
- Context preservation.
- Session management.

### Tool Integration Layer
- Connectors or APIs for external tools (databases, search, calculators, web services).
- API authentication and management.
- Tool result processing.

### Agent Registry
- Catalog of available agents and capabilities with metadata.
- Agent discovery and selection.
- Capability matching.

### Feedback Loop and Learning
- Pipeline that collects feedback and performance metrics for retraining models.
- User feedback collection.
- Model improvement workflows.

### Logging & Telemetry
- Centralized logs of all queries, responses, and agent decisions for monitoring and debugging.
- Performance metrics collection.
- Audit trail maintenance.

### Security and Privacy Controls
- Ensures sensitive data is anonymized or protected in model interactions.
- Data masking and filtering.
- Privacy policy enforcement.

### User Interface / API
- Front-end for human users or APIs for other systems to interact with the agent platform.
- Conversation interface design.
- API documentation and testing.
```

## Enterprise Integration Platforms

### Specific Requirements Patterns

```markdown
### Connectivity and Integration
- THE system SHALL support a variety of communication protocols (HTTP/REST, SOAP, AMQP, MQTT, JMS, etc.).
- THE system SHALL provide centralized API management, including routing, security, and throttling.
- THE system SHALL enable orchestration of message flows and business processes across multiple systems.
- THE system SHALL implement message transformation and enrichment (e.g. XML/JSON conversion, data mapping).

### Reliability and Monitoring
- THE system SHALL ensure reliable message delivery with transaction support and retry policies.
- THE system SHALL provide a schema registry or contracts management for message formats.
- THE system SHALL include monitoring and logging for all integration flows.
- THE system SHALL allow decentralized deployment (local gateways) or centralized bus depending on needs.

### Security and Scalability
- THE system SHALL integrate with enterprise identity and access control systems (e.g. LDAP, SSO).
- THE system SHALL support high throughput and scalability for large volumes of messages.
```

### Architecture Components

```markdown
### API Gateway
- Manages and secures API calls, routes requests to backend services, handles rate limiting.
- API documentation and testing.
- API versioning and lifecycle management.

### Message Broker/ESB
- Central messaging infrastructure (e.g. Kafka, RabbitMQ, Mule ESB) for asynchronous communication.
- Message routing and transformation.
- Queue management and monitoring.

### Connector/Adapter Library
- Pre-built connectors for common systems (ERP, databases, SaaS platforms) to simplify integration.
- Connector configuration and customization.
- Connector lifecycle management.

### Transformation Engine
- Component (e.g. Apache Camel, XSLT) to map and convert message formats between systems.
- Data mapping rules.
- Transformation validation.

### Integration Server / Orchestrator
- Coordinates complex workflows or service orchestrations (e.g. Camunda, Azure Logic Apps).
- Process modeling and execution.
- Workflow monitoring and management.

### Monitoring Dashboard
- Tracks integration flows, message queue depth, error rates, and system health.
- Performance metrics visualization.
- Alert configuration and notification.

### Configuration Repository
- Stores integration flow definitions and transformation rules (could be code or XML/JSON configs).
- Version control for configurations.
- Configuration deployment.

### Security Layer
- Encryption, token management, and certificate handling for inter-system communication.
- Authentication and authorization.
- Security policy enforcement.

### Registry & Discovery
- Service registry (e.g. Consul, etcd) for discovering endpoints of various integrated services.
- Service health monitoring.
- Dynamic endpoint resolution.

### Logging & Auditing
- Centralized logging for integration transactions and change tracking.
- Audit trail maintenance.
- Compliance reporting.
```

## Common Non-Functional Requirements

### Performance
```markdown
- Response time: p95 < 200ms, p99 < 500ms
- Throughput: >1000 requests per second
- Concurrent users: >10,000
- Database queries: <50ms
- Cache hit rate: >90%
```

### Scalability
```markdown
- Horizontal scaling capability
- Auto-scaling based on metrics
- Database sharding strategy
- Stateless service design
- Load balancer configuration
```

### Reliability
```markdown
- Uptime: 99.9% availability
- RTO: <1 hour
- RPO: <5 minutes
- Automated failover
- Data replication strategy
```

### Security
```markdown
- TLS 1.3 for all communications
- OAuth 2.0/JWT authentication
- Role-based access control
- Audit logging
- Encryption at rest
- Input validation
- SQL injection prevention
- XSS protection
- Rate limiting
- DDoS protection
```

### Monitoring
```markdown
- Application metrics (Prometheus)
- Distributed tracing (Jaeger/Zipkin)
- Centralized logging (ELK stack)
- Error tracking (Sentry)
- Uptime monitoring
- Custom dashboards
- Alert configuration
- SLA tracking
```

## Cross-Cutting Concerns

### DevSecOps
- Implement CI/CD with automated security scans
- Enforce SBOM (Software Bill of Materials) for all builds
- Enable policy-as-code (OPA, Conftest)
- Integrate secrets management (Vault, SSM)
- Implement GitOps for infrastructure deployment

### Data Governance
- Maintain centralized metadata catalog (DataHub, Amundsen)
- Apply data classification and retention policies
- Automate lineage tracking
- Enforce PII masking and anonymization
- Support regulatory compliance (GDPR, HIPAA)

### Observability Maturity
Level 1: Metrics only
Level 2: Metrics + Centralized Logs
Level 3: Metrics + Logs + Traces
Level 4: Business KPIs + SLO Dashboards
Level 5: Autonomous Remediation (AIOps)

### High Availability Blueprint
- Active-active regional clusters
- Read replicas for critical databases
- Zero-downtime deployments
- Circuit breaker patterns for dependencies
- Stateful failover validation testing

### API Governance
- Consistent naming and versioning (v1, v2)
- Schema validation and contract testing
- Rate limit and quota enforcement
- Consumer onboarding workflow
- Deprecation policy automation

## Task Breakdown Patterns by Domain

### Trading System Tasks
```markdown
1. Market Data Integration
   - Exchange API setup
   - WebSocket implementation
   - Data normalization
   - Storage optimization

2. Strategy Development
   - Indicator calculation
   - Pattern detection
   - Signal generation
   - Backtesting framework

3. Execution System
   - Order management
   - Position tracking
   - Risk controls
   - Performance analytics
```

### Real-time System Tasks
```markdown
1. Connection Layer
   - WebSocket server
   - Session management
   - Load balancing
   - Failover handling

2. Message Processing
   - Message routing
   - Persistence layer
   - Delivery guarantees
   - Presence tracking

3. Client SDKs
   - JavaScript SDK
   - Mobile SDKs
   - Reconnection logic
   - Offline support
```

### E-commerce Tasks
```markdown
1. Product Management
   - Catalog setup
   - Search implementation
   - Inventory system
   - Media handling

2. Purchase Flow
   - Cart implementation
   - Checkout process
   - Payment integration
   - Order processing

3. Customer Experience
   - User accounts
   - Recommendations
   - Reviews/ratings
   - Customer service
```

### CMS Tasks
```markdown
1. Content Creation
   - Editor implementation
   - Media management
   - Version control
   - Workflow automation

2. Content Delivery
   - API development
   - Template engine
   - Caching layer
   - CDN integration

3. Content Management
   - User permissions
   - Content scheduling
   - Search functionality
   - Analytics integration
```

### IoT Tasks
```markdown
1. Device Management
   - Device onboarding
   - Firmware updates
   - Device authentication
   - Device monitoring

2. Data Pipeline
   - Data ingestion
   - Stream processing
   - Data storage
   - Data analytics

3. Edge Computing
   - Edge deployment
   - Local processing
   - Connectivity management
   - Synchronization
```

### Machine Learning Tasks
```markdown
1. Data Pipeline
   - Data ingestion
   - Feature engineering
   - Data validation
   - Data versioning

2. Model Development
   - Experiment tracking
   - Model training
   - Model evaluation
   - Model versioning

3. Model Deployment
   - Model serving
   - Performance monitoring
   - A/B testing
   - Model retraining
```

### Developer Tools Tasks
```markdown
1. Core Infrastructure
   - Version control setup
   - CI/CD pipeline
   - Artifact repository
   - Build automation

2. Development Environment
   - IDE integration
   - Testing framework
   - Debugging tools
   - Documentation system

3. Collaboration
   - Code review process
   - Issue tracking
   - Communication tools
   - Knowledge sharing
```

### SaaS Tasks
```markdown
1. Tenant Management
   - Tenant onboarding
   - Data isolation
   - Configuration management
   - Billing integration

2. Application Development
   - Multi-tenant architecture
   - Feature flags
   - Customization framework
   - API development

3. Operations
   - Monitoring
   - Scaling
   - Backup/Recovery
   - Security compliance
```

### Data Lakehouse Tasks
```markdown
1. Data Infrastructure
   - Storage setup
   - Metadata catalog
   - Query engine
   - Data governance

2. Data Processing
   - Ingestion pipelines
   - ETL/ELT processes
   - Data transformation
   - Quality checks

3. Analytics
   - BI integration
   - Dashboard development
   - ML pipeline
   - Reporting automation
```

### AI Agent Tasks
```markdown
1. Agent Development
   - Model integration
   - Prompt engineering
   - Workflow design
   - Tool integration

2. Orchestration
   - Agent coordination
   - State management
   - Error handling
   - Performance optimization

3. Operations
   - Monitoring
   - Logging
   - Feedback collection
   - Model updates
```

### Enterprise Integration Tasks
```markdown
1. Connectivity
   - API development
   - Message broker setup
   - Connector development
   - Protocol handling

2. Integration Logic
   - Transformation rules
   - Workflow design
   - Error handling
   - Transaction management

3. Operations
   - Monitoring
   - Logging
   - Security
   - Performance tuning
```

## Testing Strategies by Domain

### Financial Systems
- Market data replay testing
- Strategy backtesting
- Risk scenario testing
- Regulatory compliance testing
- Latency benchmarking

### Real-time Systems
- Connection stress testing
- Message ordering verification
- Failover testing
- Network partition testing
- Client compatibility testing

### E-commerce
- Load testing (Black Friday simulation)
- Payment gateway testing
- Inventory accuracy testing
- Cart abandonment testing
- Cross-browser testing

### CMS
- Content workflow testing
- Permission testing
- Search functionality testing
- Template rendering testing
- Multi-channel delivery testing

### IoT
- Device scalability testing
- Network reliability testing
- Data integrity testing
- Edge computing testing
- Security vulnerability testing

### Machine Learning
- Model accuracy testing
- Data drift detection testing
- Performance benchmarking
- A/B testing validation
- Bias and fairness testing

### Developer Tools
- Build pipeline testing
- Integration testing
- Performance testing
- Security scanning
- Usability testing

### SaaS
- Tenant isolation testing
- Multi-tenancy performance testing
- Subscription billing testing
- Customization testing
- Security compliance testing

### Data Lakehouse
- Data quality testing
- Query performance testing
- Schema evolution testing
- Governance compliance testing
- Security access testing

### AI Agent
- Conversation flow testing
- Integration testing
- Performance testing
- Safety and bias testing
- User experience testing

### Enterprise Integration
- End-to-end flow testing
- Message transformation testing
- Error handling testing
- Performance testing
- Security testing

## Deployment Patterns

### High-Frequency Trading
```markdown
# Colocation deployment
- Bare metal servers
- Kernel bypass networking
- CPU isolation
- NUMA optimization
- Dedicated network paths
```

### Real-time Systems
```markdown
# Low-latency deployment
- Edge computing locations
- WebSocket optimization
- Connection pooling
- Geographic distribution
- Real-time monitoring
```

### E-commerce
```yaml
# Scalable web deployment
- Auto-scaling groups
- CDN configuration
- Database sharding
- Cache layers
- Payment gateway integration
```

### CMS
```markdown
# Content delivery deployment
- Headless architecture
- CDN integration
- Multi-region deployment
- Content replication
- Preview environments
```

### IoT
```markdown
# Edge + Cloud hybrid
- Edge gateway deployment
- Cloud orchestration
- Message queue setup
- Time-series database
- Analytics pipeline
```

### Machine Learning
```markdown
# ML platform deployment
- GPU clusters
- Model serving infrastructure
- Feature store
- Experiment tracking
- Model registry
```

### Developer Tools
```markdown
# DevOps platform deployment
- Container orchestration
- CI/CD pipeline
- Artifact repository
- Monitoring stack
- Self-service environments
```

### SaaS
```markdown
# Multi-region deployment
- Geographic load balancing
- Regional data residency
- CDN configuration
- Database replication
- Disaster recovery
```

### Data Lakehouse
```markdown
# Analytics platform deployment
- Data lake storage
- Query engine cluster
- Metadata catalog
- BI tools integration
- Security controls
```

### AI Agent
```markdown
# AI platform deployment
- Model serving infrastructure
- Orchestration engine
- Monitoring and logging
- Feedback pipeline
- Security controls
```

### Enterprise Integration
```markdown
# Integration platform deployment
- API gateway cluster
- Message broker
- Integration runtime
- Monitoring dashboard
- Security infrastructure