Polyglot Persistence is a core pattern in S90.05 for using different data storage technologies chosen based on how data is used by individual services. It directly addresses the concern of a monolithic database becoming a bottleneck by allowing the team to select a purpose-built, scalable data store (like a document or key-value database) specifically for the product catalog service’s query needs, promoting loose coupling and independent scalability.

The Saga pattern is specifically designed to manage data consistency across multiple services in distributed transaction scenarios without using traditional two-phase commit. It uses a sequence of local transactions, each updating a single service. If a step fails, compensating transactions are executed to undo the previous steps, ensuring the system eventually reaches a consistent state, which fits the described requirement perfectly.

CQRS (Command Query Responsibility Segregation) advocates for separating the model for updating information (commands) from the model for reading information (queries). This allows the team to optimize the read side (e.g., using a denormalized database, caching, or a different storage technology) specifically for the complex analytical queries of the dashboard, without impacting the performance of the transaction processing write side.

Event Sourcing persists the state of a business entity as a sequence of state-changing events. Instead of storing just the current state, the system stores the full history of events. This creates a permanent, immutable audit log by design, allowing the complete history of any entity to be replayed to reconstruct past states or to derive new read models, directly fulfilling the compliance requirement.

A distributed in-memory key-value store (like Redis or Memcached) is the archetypal solution for session storage. It provides the required low-latency, high-throughput access for simple key-based lookups (e.g., session ID). Its distributed nature offers high availability and scalability, and it can be configured with appropriate expiration policies, making it a practical and standard choice for this scenario.

A Time-Series Database (TSDB) is explicitly optimized for handling sequences of data points indexed by time. It excels at high-volume ingestion of time-stamped data and provides specialized, efficient functions for querying data over time windows—exactly the workload described for IoT sensor readings. Using a TSDB is a practical application of the Polyglot Persistence principle for this specific data shape and access pattern.

While service-owned databases promote autonomy, they make maintaining data consistency across services a significant challenge. A business transaction that updates data in multiple services can no longer rely on a single ACID transaction. This is a fundamental challenge in distributed data management, necessitating patterns like Saga, Event-Driven Architecture, or eventual consistency models to coordinate changes across these bounded contexts.

The Materialized View pattern involves pre-computing and persisting a query result so that it can be read efficiently. In an Event Sourcing system, listeners subscribe to the stream of events and update these materialized views (projections) in response. This allows the system to derive as many specialized, optimized read models as needed from the single source of truth (the event log), which is a standard and powerful combination.

Graph Databases are built to store and navigate relationships. They treat relationships between entities as first-class citizens. Queries that involve traversing multiple hops through a network of connections (like friend-of-a-friend or product associations) are native and highly efficient operations for a graph database, making it the ideal Polyglot Persistence choice for this specific, relationship-intensive use case over a relational model.

Polyglot Persistence is a core pattern in S90.05 for using different data storage technologies chosen based on how data is used by individual services. It directly addresses the concern of a monolithic database becoming a bottleneck by allowing the team to select a purpose-built, scalable data store (like a document or key-value database) specifically for the product catalog service’s query needs, promoting loose coupling and independent scalability.0