Free S90.08 Practice Test Questions and Answers (2026)

The Service Façade design pattern is applied to introduce an abstraction layer that decouples the service contract from its underlying implementation. This pattern is intentionally versatile. The underlying implementation that the façade abstracts can be a complex legacy system with a non-standard API, a specific resource such as a database requiring complex queries, or any other collection of backend functions and data sources. The primary goal is to provide a simplified, unified service interface, thereby hiding the complexity of the underlying systems, whatever their nature. Therefore, all the listed options represent valid scenarios for applying this pattern.

A, B, C: These options are individually correct but incomplete. The Service Façade pattern is not limited to abstracting only databases, only generic resources, or only legacy systems; it can be used for all of them.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall. In Chapter 11, the Service Façade pattern is detailed. The problem description explicitly states, "How can a service best be designed to abstract the logic and technology of a backend environment?" (p. 298). The solution explains that the façade abstracts the "underlying implementation," which can include legacy systems, custom components, or various resources.

2. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. The original Façade pattern, from which Service Façade is derived, is defined as providing "a unified interface to a set of interfaces in a subsystem" (p. 185). This subsystem can be composed of any number of complex components, including databases, legacy code, or other resources.

3. University of Waterloo, ECE 452: Software Design and Architectures Course Notes. The Façade pattern is described as a structural pattern used to simplify the interface to a complex subsystem. The notes illustrate that this "subsystem" can be a library, a framework, or a collection of legacy classes, which aligns with the options provided.

The statement is false because it describes the inverse of the correct application of the Messaging Metadata design pattern. The fundamental principle of this pattern is to separate the primary business data from the supplementary, descriptive data used for message processing. The correct and customary implementation is to place the supplementary messaging metadata (e.g., routing information, security credentials, correlation IDs) into the message header and the primary business document data (the payload) into the message body. This allows intermediary services and messaging infrastructure to efficiently access and process the metadata in the header without needing to parse the potentially large and complex business data in the body.

The option "True" is incorrect because it endorses a flawed and inefficient implementation that contradicts the core purpose of the Messaging Metadata pattern. Placing the business document in the header and metadata in the body would force any intermediary service that needs to make a routing or processing decision to parse the entire business document, which is computationally expensive and defeats the efficiency gains the pattern is designed to provide. The message body is intended for the payload, while the header is specifically designed for lightweight, easily parsable metadata.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall. In the detailed description of the Messaging Metadata (118) pattern, the "Solution" section explicitly states: "The solution is to place the business data within the message body and the supplementary metadata in the message header." (p. 119). The problem statement for the pattern also highlights the issue of "commingling" data, which this incorrect implementation would represent.

2. Erl, T., et al. (2008). Web Service Contract Design and Versioning for SOA. Prentice Hall. Chapter 11, "Advanced Messaging," discusses the structure of SOAP messages, reinforcing the standard practice that the SOAP Header is the designated location for metadata (processing instructions, transaction information), while the SOAP Body contains the application-specific payload. This aligns directly with the principles of the Messaging Metadata pattern.

3. Papazoglou, M. P. (2012). Web Services & SOA: Principles and Technology (2nd ed.). Pearson. Chapter 7, "Messaging with SOAP," describes the structure of a SOAP message, explaining that the element is optional and "contains context information, such as security, transaction, or routing information," while the element is mandatory and "contains the application-specific message (payload)." This university-level textbook confirms the standard separation of metadata and payload.

The Reliable Messaging pattern introduces an intermediary, typically a service agent, to guarantee message delivery between a service consumer and provider. This agent's primary responsibility is to manage the message lifecycle until successful delivery is confirmed. To do this, it must process acknowledgements. It processes positive acknowledgements (ACKs) to confirm a message was successfully received, at which point it can cease retry attempts. It also processes negative acknowledgements (NACKs) or handles timeouts to recognize delivery failures, trigger retry logic, or escalate the failure as required.

C. service agents can load balance messages This describes the primary function of the Service Broker or Load Balancer patterns, which focus on distributing workloads, not guaranteeing message delivery.
D. service agents can route messages based on their content This is the specific purpose of the Content-Based Router pattern, which directs messages to different endpoints based on their content, a separate concern from reliability.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Chapter 15, Reliable Messaging Pattern: The pattern description explicitly details the role of a reliable messaging agent. The solution section states, "The reliable messaging system is responsible for persisting messages it receives and continuing to attempt delivery of a message until it receives an acknowledgement from the service that the message was successfully received." This confirms the processing of positive acknowledgements (A). The pattern's logic for handling delivery failures and retries inherently involves processing negative acknowledgements or timeout events (B).

Chapter 15, Content-Based Router Pattern: This pattern is presented separately and is dedicated to the problem described in option D.

Chapter 15, Service Broker Pattern: This pattern addresses logic for message distribution and load balancing, as described in option C.

The statement is correct. In the context of Arcitura's SOA methodology, architectural scopes are hierarchical. A broader, enterprise-level architecture establishes a set of standards, governance constraints, conventions, and technological platforms. More specific, domain-level architectures, such as those for individual service inventories, are designed within the context of this enterprise framework. Therefore, a service inventory architecture inherits and must conform to the features (e.g., security standards, communication protocols) and limitations (e.g., technology choices, governance policies) defined by the overarching service-oriented enterprise architecture. This ensures consistency, interoperability, and alignment with enterprise-wide strategic goals.

The statement is not False because treating different SOA scopes as independent would defeat the purpose of enterprise architecture. If a service inventory architecture did not inherit constraints from the enterprise architecture, it would lead to architectural silos, redundant solutions, and a lack of enterprise-wide governance and interoperability, which are the very problems that a service-oriented enterprise aims to solve.

1. Erl, T. (2008). SOA: Principles of Service Design. Prentice Hall.

Chapter 5: Service-Orientation and the Enterprise, Section 5.2, "The Service-Oriented Enterprise (SOE)," explains how an SOE establishes a "common, standardized, and governed IT enterprise." This enterprise-level standardization is the foundation that is inherited by all subsequent architectural efforts, including service inventories.

Chapter 16: Service Inventory Design (A Process), Section 16.2, "Step 1: Compose the SOA design," describes the creation of a service inventory blueprint. This blueprint is explicitly defined by and aligned with enterprise-wide standards and business goals, demonstrating the inheritance of features and constraints from the broader enterprise scope.

2. Erl, T., et al. (2009). SOA Design Patterns. Prentice Hall.

Pattern 1: Service Inventory, in the "Solution" section, describes a service inventory as an "independently standardized and governed collection of complementary services." The term "standardized and governed" implies the existence of a higher authority or a broader architectural scope (the enterprise) that imposes these standards and governance rules, which the inventory architecture must then adopt.

3. Arcitura Education Inc. (2017). S90.01B: Fundamental SOA & Service-Oriented Computing Course Booklet.

Module 1: Fundamental SOA, Service-Oriented Computing & SOA, in the section on "The Service-Oriented Enterprise," establishes that the SOE provides an enterprise-wide architectural model. Subsequent modules on service inventories explain that these inventories are realized within the context and constraints of this enterprise model.

Service agents are event-driven programs, often provided as part of a vendor's middleware platform (such as an ESB or orchestration engine), that can intercept and process messages. While they offer powerful capabilities for extending service architectures, their implementations are frequently proprietary to the underlying vendor technology. Consequently, building an architecture that heavily relies on these specific, non-standardized service agents creates a strong dependency on the vendor's platform. This dependency, also known as vendor lock-in, makes it difficult and costly to migrate to a different platform in the future, thereby compromising architectural agility and vendor diversity.

B. The use of service agents is limited to the service architecture. This is incorrect. While service agents are a component within a service architecture's infrastructure, the underlying pattern of an event-driven interceptor is not exclusive to SOA and can be applied in other architectural contexts.
C. Service agents are common in orchestration environments but not within enterprise service bus environments. This is false. Both orchestration engines and Enterprise Service Buses (ESBs) are common middleware environments where service agents (or equivalent interceptors) are deployed to augment message processing logic.
D. None of these statements are true. This is incorrect because statement A is a valid and recognized architectural risk associated with the implementation of service agents.

1. Erl, T. (2008). SOA: Principles of Service Design. Prentice Hall.

Page 474, Chapter 16, "Common SOA Pitfalls": This chapter discusses the pitfall of "Vendor Lock-in," which arises from dependencies on proprietary technologies. The overuse of vendor-specific features, such as their implementation of service agents, is a direct cause of this issue. The text explains that relying on proprietary extensions limits portability and increases migration costs.

Page 198, Chapter 8, "Service Models and Service Layers": The section on the Enterprise Service Bus describes how this middleware can be extended with "processing agents" to intercept and act upon messages, confirming their use in ESB environments.

Page 95, Chapter 5, "SOA and Service-Orientation": The definition of a service agent is provided as "an event-driven program capable of intercepting and processing messages." The context implies its implementation is tied to the underlying runtime environment, which is often vendor-specific.

The statement is correct. A fundamental strategic goal of establishing a service inventory architecture is to enable service composition. The architecture is intentionally designed to create a collection of standardized, reusable, and interoperable services. This design ensures that individual services can be discovered and assembled in various combinations (composition) to automate different business processes or create new composite services. The ability to easily change these combinations (recomposition) provides the organizational agility that is a primary benefit of Service-Oriented Architecture (SOA).

This is a "TRUE or FALSE" question, so there is only one alternative. The statement being "False" would imply that a service inventory's architecture is unrelated to or not designed for service composition. This is fundamentally incorrect, as it negates the core purpose of creating a standardized inventory of services, which is to foster reuse and enable the creation of composite solutions.

1. Erl, T. (2008). SOA: Principles of Service Design. Prentice Hall.

Page 104, Section 5.3, "Service Composability (Principle)": The text explicitly states, "Services within a service inventory are designed to be composable." It further explains that this principle is central to realizing the benefits of SOA, as it allows services to be assembled into "any number of service compositions." The design of the inventory architecture is what supports and enforces this principle.

2. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Page 101, Section 5.1, "Service Inventory": This section describes the service inventory as "the sum of all services that are actively managed and governed within an enterprise's IT environment." It continues to explain that this inventory forms the basis for creating "effective service compositions." The pattern emphasizes that the inventory's structure is a prerequisite for successful composition.

3. Papazoglou, M. P. (2003). Service-Oriented Computing: Concepts, Characteristics and Directions. Proceedings of the Fourth International Conference on Web Information Systems Engineering (WISE'03).

Section 4.2, "Service Composition and Interoperation": The paper discusses that a key aspect of service-oriented computing is the ability to create composite services by aggregating existing ones. It states, "A composite service’s implementation is defined by a composition of operations of other services." This capability relies on an underlying architecture of discoverable and interoperable services, which is the essence of a service inventory architecture. (DOI: https://doi.org/10.1109/WISE.2003.1254461)

The Messaging Metadata design pattern is fundamentally based on the principle of augmenting a message with supplementary data (metadata) without altering the primary business payload contained within the message body. This metadata—such as correlation IDs, security tokens, or routing information—is placed into dedicated header blocks or property fields provided by the underlying messaging technology. Therefore, the successful application of this pattern is entirely contingent upon using a messaging framework that natively supports messages with distinct headers or properties that can be independently processed.

The option "False" is incorrect because it would suggest that the Messaging Metadata pattern could be implemented on a system that does not support message headers or properties. This contradicts the pattern's core solution. If metadata were embedded within the message body itself, it would violate the pattern's primary goal of separating metadata from the payload, leading to a more tightly coupled and less flexible solution. This alternative approach would not be an implementation of the Messaging Metadata pattern.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall. In Chapter 12: Service Messaging Patterns, the "Messaging Metadata (5.6)" pattern is detailed. The solution section explicitly states, "Metadata is added to the message in the form of one or more message headers" (p. 379). The "Application" section further clarifies that this pattern requires a messaging product that supports the use of message headers.

2. Arcitura Education Inc. (2022). S90.09B: Advanced SOA Design & Architecture with Services & Microservices. Module 9: Service Messaging Design Patterns. The description of the Messaging Metadata pattern establishes that its implementation relies on leveraging the header or properties feature of the messaging middleware to carry contextual and technical data separately from the business data in the message body.

The Messaging Metadata pattern is fundamentally about enriching a message with supplementary data (metadata) that is processed separately from the primary business data (the payload). This metadata is crucial for enabling stateful and conversational message exchanges. For instance, metadata such as correlation identifiers, session IDs, or sequence numbers are used to track and manage the state of a long-running conversation between a service consumer and provider. Therefore, the statement that the pattern is not applicable to these situations is false; in fact, it is a key enabler for them.

A: This is a true statement. The WS- (Web Services) specifications extensively use SOAP header blocks to carry metadata for functions like addressing (WS-Addressing), security (WS-Security), and reliable messaging (WS-Reliable Messaging), which are concrete implementations of the Messaging Metadata pattern. B: This is a true statement. To implement the Messaging Metadata pattern, the underlying messaging technology or framework must provide an API or mechanism for senders to add metadata (as headers or properties) and for receivers or intermediaries to read and process it. D: This is a true statement. Patterns like Intermediate Routing rely on routing-specific information (e.g., a routing slip or dynamic destination addresses) being included with the message. The Messaging Metadata pattern provides the standard mechanism to carry this data without altering the message's core payload.

Erl, T. (2009). SOA Design Patterns. Prentice Hall.

For Correct Answer (C): In the description of the Correlation Identifier pattern, it is stated that "This pattern is almost always dependent on the application of the Messaging Metadata pattern..." (p. 379). The Correlation Identifier pattern is explicitly designed to manage state in asynchronous conversations, demonstrating that Messaging Metadata is essential for, not inapplicable to, stateful exchanges.

For Incorrect Option (A): The Messaging Metadata pattern description states, "The most common implementation of this pattern is the use of SOAP header blocks..." and later mentions, "The emergence of numerous WS- specifications has further standardized the use of SOAP headers..." (p. 375).

For Incorrect Option (D): The "Pattern Relationships" section for Messaging Metadata notes that it "can be used to support the application of patterns such as... Intermediate Routing... by supplementing messages with activity-specific metadata" (p. 376).

The Atomic Service Transaction pattern leverages traditional ACID (Atomicity, Consistency, Isolation, Durability) transactions, which are suitable for short-lived, real-time processes where resources can be locked. This pattern relies on the underlying transaction coordinator to automatically roll back all changes if any part of the operation fails. Conversely, the Compensating Service Transaction pattern is designed for long-running business activities where holding resource locks is impractical. It does not use a traditional rollback. Instead, if a failure occurs after some steps have already committed, it executes pre-defined, custom "compensating" logic to semantically undo the completed steps. Therefore, all three statements accurately describe key differences between the patterns.

A: This statement is correct but incomplete. It only addresses the difference in suitable processing duration, which is just one of several key distinctions. B: This statement is correct but incomplete. It focuses solely on the rollback mechanism, omitting other critical differences like activity duration and logic implementation. C: This statement is correct but incomplete. It highlights the difference in exception handling logic without mentioning the underlying reasons related to transaction duration and type.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Atomic Service Transaction Pattern (p. 463): "This pattern is generally applied to business processes that are short-lived... It relies on a transaction protocol and a coordinator that can enforce the all-or-nothing outcome of an atomic transaction." This supports options A and B.

Compensating Service Transaction Pattern (p. 471): "A pattern that allows a series of service operations to be processed as a single unit of work... while avoiding the need to lock resources for the entire duration of the business activity." This supports option A.

Compensating Service Transaction Pattern (p. 472): "The logic required to reverse the effects of a previously completed operation is encapsulated in a special-purpose operation referred to as a compensation... This is different from a simple rollback in that the reversal logic is explicitly defined and designed." This supports options B and C.

The Atomic Service Transaction pattern's primary goal is to ensure that a series of operations distributed across multiple services are executed as a single, indivisible unit of work. This "all-or-nothing" behavior is precisely what the WS-AtomicTransaction standard is designed to facilitate. WS-AtomicTransaction, in turn, relies on the extensible framework provided by WS-Coordination to manage the context and propagation of the transaction across participants. Therefore, these two standards provide a standardized technology platform for applying the Atomic Service Transaction pattern.

The option "False" is incorrect because the WS-Coordination and WS-AtomicTransaction specifications were explicitly created to address the challenges of managing distributed transactions in a service-oriented environment. The Atomic Service Transaction pattern formalizes the design solution, and these standards provide the concrete mechanism for its implementation.

1. Erl, T., et al. (2009). SOA Design Patterns. Prentice Hall. In Chapter 15, "Composition Patterns," the section on the Atomic Service Transaction pattern explicitly states: "The application of this pattern is commonly reliant on the use of the WS-Coordination and WS-AtomicTransaction specifications..." (p. 437). The text further details how the coordinator established by WS-Coordination is used by WS-AtomicTransaction to execute the two-phase commit protocol central to the pattern's logic.

2. Arcitura Education Inc. (2017). S90.09: Advanced SOA Design & Architecture Course Booklet. In Module 9: "Advanced Service Composition," the description of the Atomic Service Transaction pattern identifies WS-Coordination and WS-AtomicTransaction as the primary implementation standards for achieving transactional integrity in service compositions.

3. OASIS (2007). Web Services Atomic Transaction (WS-AtomicTransaction) Version 1.1. OASIS Standard. Section 1, "Introduction," states that the specification "provides the definition of an atomic transaction coordination type that is to be used with the coordination framework described in the WS-Coordination specification." This confirms that the standard is designed to work with WS-Coordination to implement atomic transactions.

The Service Broker is a compound design pattern that establishes a centralized intermediary for message processing, routing, and transformation. Its core purpose is to decouple services by handling incompatibilities between them. This explicitly includes the capability to transform message payloads by applying both the Data Model Transformation pattern (to alter the data's semantic structure between different schemas) and the Data Format Transformation pattern (to convert the message's physical format, such as from XML to JSON). These patterns are fundamental components that can be realized within a Service Broker implementation.

C. Transaction Protocol Transformation: This is not a standard Arcitura design pattern. The related pattern is Protocol Bridging, which handles transformations between communication protocols (e.g., HTTP to JMS), not specifically "transaction protocols."
D. Policy Transformation: A service broker typically acts as a policy enforcement point, applying existing policies to messages. It is not primarily designed to perform "policy transformation" as a distinct function.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Page 498, Section 15.3 (Service Broker): The text and diagrams explicitly state that the Service Broker pattern is a compound pattern that can be composed of several other patterns, including Data Model Transformation and Data Format Transformation. Figure 15.11 illustrates this composition.

Page 388, Section 12.2 (Data Model Transformation): Describes the pattern that a Service Broker can implement to resolve schematic dissimilarities between services.

Page 394, Section 12.3 (Data Format Transformation): Details the pattern for converting data between different formats, a common function applied within a Service Broker.

The Rules Centralization pattern abstracts business rules into a separate, centrally managed component, often a rules engine exposed as a dedicated service.
(A) This centralizes the governance and evolution of business rules from a single point of control.
(B) It reduces logic redundancy by ensuring that common rules are defined once and reused by multiple services.
(C) A key feature of this pattern is enabling the dynamic modification and application of rules at runtime without requiring the redeployment of consumer services.
(D) A known trade-off is the reduction of service autonomy, as consumer services become dependent on the central rules service to execute parts of their logic.

All the provided options are correct statements describing the purpose, benefits, and consequences of applying the Rules Centralization pattern.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Chapter 15: Service Composition Design Patterns, Section: Rules Centralization. The pattern's summary explicitly states its goal is to centralize business rules to "avoid redundancy and increase their reusability and agility" (supports B). The solution describes isolating rules into a rules engine, which facilitates centralized governance and runtime application (supports A and C). The "Impacts" section for the pattern explicitly lists "Reduced service autonomy" as a primary consequence (supports D).

The Service Agent pattern describes an event-driven, intermediary program that transparently intercepts and processes messages for purposes such as routing, validation, or reliability. Several other design patterns depend on this fundamental pattern for their implementation. Reliable Messaging requires logic to persist messages, manage acknowledgements, and handle retries. This logic is commonly encapsulated within a service agent to separate reliability concerns from business logic. Intermediate Routing is fundamentally implemented by a specialized service agent (a router) that intercepts messages to determine their proper destination. Policy Centralization requires a component to intercept service messages and apply centralized rules (e.g., security, logging). This "policy enforcer" is a direct implementation of the Service Agent pattern.

B. Asynchronous Queuing: This pattern's primary component is a message queue used to decouple service consumers and providers. It does not inherently require an intermediary service agent for its core function.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Intermediate Routing: The solution is explicitly defined as: "By introducing an intermediary service agent that can dynamically route messages..." (p. 351). The pattern relationship diagram also shows that "Service Agent is applied by Intermediate Routing" (p. 356).

Reliable Messaging: The pattern's solution involves a "reliability module" to handle message persistence and acknowledgements. The pattern relationship diagram explicitly states, "Service Agent is applied by Reliable Messaging" (p. 336).

Policy Centralization: This pattern is implemented via a "policy enforcer" that acts as an interceptor to apply rules. This enforcer is a type of service agent, as described in the Service Agent pattern definition which includes "validation logic" as a primary function (p. 323).

Asynchronous Queuing: The solution is to "introduce a queue between the service and the service consumer." The pattern description does not mention a requirement for a service agent (p. 339).

The Protocol Bridging pattern introduces an intermediary component to resolve incompatibilities between communication protocols used by different systems. Its primary function is to translate one protocol into another. This includes disparities at the transport layer, such as converting a message from HTTP to FTP, and at the messaging layer, such as transforming a SOAP message into a JMS message. The bridge effectively isolates the service consumer and provider from each other's specific protocol requirements, enabling interoperability between otherwise incompatible endpoints.

C. transaction protocols: This is incorrect because managing distributed transactions is addressed by dedicated transaction management patterns, not primarily by Protocol Bridging.
D. policy protocols: This is incorrect as the pattern's focus is on communication protocol translation, not the mediation or translation of security or QoS policies (e.g., WS-Policy).

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall. In Chapter 17, the "Problem" section for the Protocol Bridging pattern explicitly states, "How can services and consumers that support different communication protocols be designed to interoperate?" The "Solution" and "Application" sections provide examples of bridging both transport (HTTP, MSMQ) and messaging (SOAP) protocols. (pp. 536-539).

2. Papazoglou, M. P. (2012). Web Services & SOA: Principles and Technology (2nd ed.). Pearson. Chapter 12, Section 12.4.2, "Mediation," discusses the need for protocol transformation to bridge heterogeneity between service requesters and providers, which is the core function of the Protocol Bridging pattern. This includes transforming both transport-level and message-format-level protocols.

3. Stevens Institute of Technology. (n.d.). CS 549: Distributed Systems and Cloud Computing - Lecture 10: Web Services. Courseware. The lecture notes describe mediation patterns, including protocol bridging, as a mechanism to resolve mismatches in transport protocols (e.g., HTTP, JMS) and message formats between clients and services.

The statement is correct. The Enterprise Service Bus (ESB) is a compound design pattern that is comprised of several other, more granular patterns. One of the core functional components of the ESB is the Service Broker pattern, which is responsible for message processing logic, including routing and data model transformation. To perform these transformations consistently and reliably across an enterprise, the broker component relies on standardized and centrally governed data models (schemas). This is a direct application of the Schema Centralization pattern. Therefore, because Service Broker is a fundamental part of the ESB, and Schema Centralization is a necessary supporting pattern for the broker's transformation capabilities, Schema Centralization is also considered a constituent part of the Enterprise Service Bus compound pattern.

The "False" option is incorrect because it fails to recognize the compositional nature of the Enterprise Service Bus pattern. The ESB is not a monolithic entity but an aggregation of other patterns that provide its overall capability. The data transformation function, a key feature of an ESB, is implemented by the Service Broker, which in turn is fundamentally supported by having centralized schemas. The patterns are intrinsically linked within the context of the ESB's definition.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall. In Chapter 17, "Enterprise Service Bus," the pattern description explicitly details its composition. It lists Service Broker as a core pattern and explains that for the broker to perform its message transformation duties, it often relies on the application of the Schema Centralization pattern.

2. Arcitura Education Inc. (2017). S90.02: SOA Design & Architecture Lab Manual. The lab exercises and official course materials demonstrate the relationship where an ESB implementation uses a centralized schema repository to validate and transform messages as they are brokered between services.

3. Erl, T. (2009). SOA Design Patterns. Prentice Hall. Chapter 6, "Schema Centralization," and Chapter 10, "Service Broker." The relationship is further clarified in the "Pattern Relationships" section for both patterns, noting how Schema Centralization supports the data transformation logic required by a Service Broker.

The core function of the Intermediate Routing pattern is to decouple the service consumer from the ultimate service provider by introducing a routing intermediary. This intermediary, often implemented as a service agent, makes decisions on where to forward a message based on a set of rules. While this agent can be "active" and modify the message (e.g., for protocol bridging or data transformation), this is not a mandatory requirement of the pattern. The pattern can be correctly applied using a "passive" service agent that only inspects the message's content or metadata to determine the next destination and then forwards the message without any alteration. The fundamental purpose is the centralization and application of routing logic, not necessarily message modification.

The statement claims that service agents must be active and must change data for the pattern to be applied properly. This is incorrect because it presents an optional capability (message modification) as a mandatory requirement. The pattern's primary concern is directing message flow, a task that can be accomplished without altering the message itself, such as in simple content-based routing where the message is only read for decision-making.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall. In the description of the Intermediate Routing pattern (Pattern 5.5), the text focuses on the router's primary function to "intercept and forward messages" based on "message content and metadata." It explains that the pattern centralizes routing logic but does not mandate that the message itself be altered as part of this logic.

2. Erl, T. (2009). SOA Design Patterns. Prentice Hall. The book distinguishes between "active" and "passive" service agents. A passive agent is defined as one that can intercept and process messages without altering their contents. An intermediate router performing content-based inspection solely for forwarding purposes is a valid implementation using a passive agent, demonstrating that message modification is not a prerequisite for the pattern.

The Process Centralization pattern addresses the issue of business process logic being scattered across multiple services. Its primary goal is to abstract and consolidate this distributed logic into a single, dedicated parent process service. This service acts as the sole orchestrator for the business process, creating a central point of control for execution, management, and monitoring. The term "physically centralizes" refers to the consolidation of the process definition and its runtime management into a distinct, deployable component (the process service), which represents a single location for this logic.

B. logically centralizes business process logic into a separate service layer: This is less accurate. While the resulting process service exists within a process or orchestration layer, the pattern's core action is the tangible consolidation of logic into a single component, which is better described as a physical centralization.
C. physically centralizes task services into an enterprise service bus: This is incorrect. The pattern centralizes business process logic (the orchestration), not the task services that execute individual steps. Task services are invoked by the central process, but they remain independent.
D. logically centralizes task services into an enterprise service bus: This is incorrect for the same reason as option C. It misidentifies the target of centralization; the pattern focuses on consolidating process control logic, not the underlying task services.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Pattern 21: Process Centralization, Page 269. The "Problem" section states: "Business process logic is distributed across multiple services, resulting in a business process that is difficult to manage, monitor, and change."

Pattern 21: Process Centralization, Page 270. The "Solution" section explains: "The business process logic is centralized in a dedicated parent business process service. This service orchestrates the underlying task services, which are designed to have their process-specific logic removed." This describes a physical consolidation into a single service component.

The problem described is the inefficiency of a polling mechanism, where a service consumer repeatedly sends requests to a service to check for data availability. The Event-Driven Messaging pattern directly solves this by inverting the communication model. Instead of the consumer pulling data, the service pushes notifications. The consumer subscribes to specific events, and the service (or an intermediary event bus) automatically sends a message to the consumer only when a relevant event occurs (e.g., new data is available). This eliminates the constant, unnecessary network traffic generated by polling.

A. The Messaging Metadata pattern focuses on enriching messages with contextual data, such as for duplicate detection. It does not change the underlying polling interaction, which is the source of the inefficiency.
C. The Atomic Service Transaction pattern addresses data consistency and integrity across multiple service operations. It is concerned with transactional behavior, not the efficiency of the communication style.
D. This option is incorrect because option B provides a direct and standard solution to the problem of inefficient polling.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Event-Driven Messaging (p. 384): The pattern description explicitly contrasts this model with the polling model: "Instead of forcing service consumers to poll services for state changes, this pattern allows services to publish state change events to which service consumers can subscribe." This directly supports the correct answer.

Messaging Metadata (p. 376): This section describes the pattern's purpose as adding header information for various technical purposes, including message processing instructions. It does not address the polling inefficiency.

Atomic Service Transaction (p. 484): This pattern is described as a mechanism to "allow a group of services to partake in a transaction that is managed and coordinated by a transaction controller." This confirms its focus is on transactional integrity, not communication efficiency.

The Intermediate Routing pattern introduces a routing component that intercepts messages between a service consumer and a service provider. A primary application of this pattern is to implement load balancing by distributing incoming requests across multiple instances of a service. This router can apply various algorithms (e.g., round-robin, least connections) to manage the workload, thereby enhancing the scalability and availability of the service. The pattern centralizes routing logic, allowing for dynamic workload distribution without affecting the service consumer or provider implementations.

A. Atomic Service Transaction: This pattern focuses on ensuring data consistency by managing all-or-nothing transactions across services, not distributing workload.
C. Service Broker: This pattern's main purpose is to abstract service endpoints and facilitate discovery, though it could be combined with routing, it is not its primary function.
D. Decoupled Contract: This pattern addresses the design of service contracts to separate business and technical details, which is unrelated to runtime message distribution.

1. Erl, T. (2008). SOA Design Patterns. Prentice Hall.

Intermediate Routing Pattern (p. 485): The pattern description explicitly states, "The intermediate routing mechanism can be designed to support a variety of routing models, including... load balancing." The text further explains how the router can distribute messages to available service instances to balance the processing load.

Atomic Service Transaction Pattern (p. 381): This section describes the pattern's role in managing ACID-level transactions, with no mention of load balancing.

Service Broker Pattern (p. 473): This pattern is defined as a means to "dynamically forward messages to different service operations or services," focusing on abstraction and discovery, not explicitly on load balancing as a primary driver.

Decoupled Contract Pattern (p. 205): This section details how to separate service contract parts to reduce dependencies, a design-time concern unrelated to runtime load distribution.

The Intermediate Routing pattern introduces a routing intermediary to avoid point-to-point coupling and to centralize routing logic. A primary function of this router is to intercept a message, inspect its contents (such as data in the message body or metadata in the header), and then forward the message to a specific destination based on pre-defined rules. This capability is known as content-based routing. This pattern decouples the initial sender from the ultimate receiver, allowing routing logic to be managed and evolved independently of the service logic.

A. Increasing service autonomy from a shared data source is typically addressed by patterns like Service Façade or by implementing data abstraction layers, not by message routing.
C. While a routing component can be used for load balancing, this specific need is more directly addressed by the dedicated Load Balancing pattern, which focuses on distributing traffic, not conditional routing.
D. Providing compensating logic for failed transactions is the specific purpose of the Compensating Service Transaction pattern, which deals with state management and error recovery in distributed processes.

1. Erl, T. (2009). SOA Design Patterns. Prentice Hall.

Page 401, Section 11.4 (Intermediate Routing), Problem: "The routing logic required to pass a message from its source to its ultimate destination is complex and may be subject to change. Hard-coding this logic into the source and destination services creates undesirable dependencies and requires that services be reprogrammed whenever the routing logic changes."

Page 403, Section 11.4 (Intermediate Routing), Solution: "An intermediate routing service is introduced to which the message is sent instead of the ultimate destination... The router can be programmed with rules that determine where to forward the message based on message content and/or metadata."

2. Erl, T., et al. (2016). Cloud Computing: Concepts, Technology & Architecture. Prentice Hall.

Page 278, Section 11.3 (Cloud Service Consumers): Discusses how routing logic can be externalized from service consumers into intermediary services, which can then perform "content-aware and context-aware routing." This aligns with the core function of the Intermediate Routing pattern.