When designing an event-driven architecture to track order processing stages (Created, Shipped, Paid), the Integration Architect must ensure the solution provides "durability"-the ability to recover messages that were sent while a subscriber was offline or during a system failure. In Salesforce, this is managed through the Event Bus and the ReplayID mechanism.
For High-Volume Platform Events and Change Data Capture, Salesforce provides a standard retention window of 72 hours (3 days). This means that events are stored in the bus for this duration, allowing clients to "replay" events that occurred in the past. To leverage this durability, the subscribing client must specify where in the event stream they wish to begin receiving messages.
There are two special values for the ReplayID:
ReplayID = -1 (Tip of the Stream): The subscriber receives only new events that are published after the subscription is established. Any events published while the client was disconnected are missed. This does not meet the requirement of seeing processing stages that occurred within the retention window if the connection was interrupted.
ReplayID = -2 (All Available Events): The subscriber receives all events that are currently stored in the event bus (up to 72 hours old) as well as all new events.
By recommending the use of ReplayID = -2, the architect ensures that even if the Salesforce frontend or the integration middleware experiences downtime, the system can "catch up" by retrieving all order status updates (Shipped, Paid, etc.) that were published during that window. This provides a robust and resilient user experience, ensuring that the Opportunity and Order records in Salesforce accurately reflect the state of the ERP system without data gaps. This configuration is essential for maintaining data synchronization in a distributed landscape where Salesforce acts as the engagement layer for a back-1end ERP master.

When migrating from a legacy environment to a multi-tenant cloud platform like Salesforce, Data volume and processing volume represent the most critical technical constraints. Legacy systems often operate without the strict governor limits found in Salesforce, meaning they may push large datasets or high-frequency updates that could easily overwhelm standard Salesforce APIs.
An integration architect must evaluate these volumes to determine the appropriate integration pattern:
Pattern Selection: If the daily volume involves millions of records, the architect must recommend the Bulk API rather than standard REST or SOAP APIs to avoid hitting daily API limits.
Synchronous vs. Asynchronous: High processing volumes often necessitate asynchronous patterns (such as Fire-and-Forget or Batch) to prevent user-interface lag and "Concurrent Request Limit" errors.
Data Virtualization: If the legacy data volume is massive but only needs to be viewed occasionally, the architect might consider Salesforce Connect to avoid consuming expensive internal data storage.
While reporting (Option A) and multi-currency (Option C) are important functional requirements, they do not fundamentally dictate the technical "plumbing" or scalability of the integration architecture. By prioritizing the analysis of volume and processing needs, the architect ensures the new modernization effort is stable, performant, and capable of scaling as the business grows within the bounds of the Salesforce platform.

To provide near real-time notifications to a client that already supports CometD, an Integration Architect should leverage the Streaming API. While Platform Events are a modern alternative, PushTopic Events are specifically designed to stream changes to Salesforce records based on a defined SOQL query.
A PushTopic event is triggered when a record is created, updated, deleted, or undeleted. By creating a PushTopic on the Opportunity object, NTO defines the criteria (fields and record states) that should trigger a message to the 1subscriber. The affiliate's CometD client can then subscribe to this topic's channel (e.g., /topic/OpportunityUpdates) to receive the data payload instantly.
Option A is incorrect because "Accept CometD API Requests" is not a standard checkbox or configuration within a Connected App; authentication is handled via standard OAuth flows, but the streaming channel must still be defined. Option C describes a Polling mechanism, which is the architectural opposite of the requested "immediate notification" and would unnecessarily consume SOAP API limits while introducing latency. By using a PushTopic, NTO ensures a decoupled, event-driven architecture that scales effectively for notification-only use cases while respecting the technical capabilities of the affiliate's existing CometD-compatible infrastructure.

The CIO's concern regarding "viability" and "scaling" is rooted in the risks associated with tightly coupled, point-to-point integrations. Using @future methods for direct callouts creates a "spaghetti" architecture where Salesforce must manage the specific endpoints, authentication, and error logic for every external system.
The architect should recommend implementing an Enterprise Service Bus (ESB). An ESB acts as a centralized middleware layer that provides mediation, routing, and orchestration. By moving the integration logic to an ESB, Salesforce only needs to send a single message to the bus. The ESB then takes responsibility for delivering that data to multiple business units and external systems. This decouples Salesforce from the downstream systems; if a target system changes its API or is replaced, only the ESB configuration needs to be updated, not the Salesforce Apex code.
While External Services (Option A) provide a low-code way to call APIs, they still represent point-to-point connections and do not solve the broader orchestration and scaling challenges. ETL tools (Option C) are designed for bulk data movement and would not satisfy the need for the near real-time updates that the existing callout logic likely supports. An ESB provides the "quality of service" features-such as guaranteed delivery, retries, and protocol transformation-that are necessary for a growing enterprise to maintain a stable and scalable integration landscape.

An Integration Architect's primary responsibility when evaluating a landscape for a new Salesforce implementation is to identify the system of record for each business process and determine which legacy systems will be replaced by Salesforce. In this scenario, the customer is implementing Salesforce specifically to support case management.
According to the provided landscape diagram, the Case Management System currently exists as a standalone entity. Since Salesforce Service Cloud provides native, best-in-class case management capabilities, this legacy system is the primary candidate for retirement. Retiring the legacy Case Management system avoids data fragmentation and ensures that Salesforce serves as the single source of truth for support interactions.
However, for Salesforce to function effectively as a new case management hub, it must integrate with the remaining surrounding systems:
Email Management System: This system likely handles inbound customer communications. An architect must evaluate integrating this with Salesforce (via Email-to-Case or a specialized connector) so that incoming emails automatically generate or update cases.
Order Management System (OMS): Support agents often need to view order history or status to resolve customer inquiries. Integrating Salesforce with the OMS allows for a 360-degree view, enabling agents to see relevant order data directly within the Salesforce case console.
Data Warehouse: For long-term reporting, trend analysis, and a unified customer profile, case data from Salesforce needs to be pushed to the Data Warehouse. This ensures that the Analytics and Business Intelligence Tool downstream can report on support metrics alongside other enterprise data.
Therefore, the architect should evaluate integrations with the Data Warehouse, Order Management, and Email Management System. Option B and C are incorrect because they suggest integrating with the "Case Management System," which is the very system being superseded by Salesforce's native capabilities. By focusing on the integration of these three supporting systems, the architect ensures a seamless transition where Salesforce is fully enriched with the necessary external data to drive support excellence.