Salesforce Plat-Arch-204 Exam Questions

The primary architectural challenge in this scenario is the massive discrepancy between the backend response time (up to 90 seconds) and the API Gateway timeout constraint (9 seconds). In any synchronous integration pattern, the connection must remain open across the entire path; if the API Gateway closes the connection at 9 seconds, a standard Salesforce 'Request-Reply' callout will fail long before the 90-second eligibility check is complete.

Option A is non-viable because synchronous polling at a high scale (3,000 concurrent users) would likely hit Salesforce concurrent request limits and place an immense, unnecessary load on the API Gateway. Option B, using Continuation, is designed to handle long-running callouts (up to 120 seconds) without blocking Salesforce threads, but it still requires the external connection path to remain open. It does not bypass the 9-second timeout imposed by the customer's API Gateway.

The optimal recommendation is Option C, which implements an Asynchronous Request-Reply pattern using Platform Events and the empAPI.12

Request Phase: The Salesforce UI initiates the request. To bypass the 9-second gateway timeout, the ESB (MuleSoft) should be configured to receive the request3 and immediately return an acknowledgment (e.g.,4 HTTP 202 Accepted). This allows the initial Salesforce callout to complete successfully within the 9-second window.56

Processing Phase: MuleSoft then proceeds with the long-running (up to 90 seconds) call to the external eligibility systems.78

Callback Phase (Remote Call-In)9: Once the eligibility result is received, MuleSoft calls back into Salesforce via the REST API to publish a Platform Event containing the result.10

UI Update (empA11PI): The 3,000 sales agents' browsers, having subscribed to the event channel using the empAPI (Lightning's built-in library for streaming events), receive the notification in real-time. The UI then updates to display the 'Display Response' step.

This event-driven architecture effectively 'insulates' Salesforce and the API Gateway from the backend's high latency, ensures scalability for 3,000 concurrent users, and provides a seamless, real-time user experience without hitting governor limits or timeout constraints.

==========

When a business process does not require immediate confirmation from a target system, the architecture can move from a synchronous Request-Reply pattern to an asynchronous Fire-and-Forget pattern. In this transition, the most critical 'non-functional' requirement for the Integration Architect is to define acceptable latency.

Latency determines the technical stack. If the fulfillment system must receive the order within seconds (Near Real-Time), the architect might choose Salesforce Outbound Messaging or a Flow-triggered Platform Event. If the order only needs to arrive within 4-12 hours, a Batch ETL process is more efficient as it conserves API limits and can handle much higher volumes more reliably.

While address validation (Option B) is a functional requirement, it does not define the architectural framework. Option C is a specific solution implementation question rather than a fundamental design constraint. By asking about latency, the architect identifies the time boundary between 'Data Entry' in Salesforce and 'Processing' in the fulfillment system. This answer directly informs the choice of pattern, the retry logic required, and the error-handling strategy needed to ensure the 'Order-to-Cash' cycle is completed successfully without blocking the sales rep's productivity.

A synchronous requirement in Salesforce implies a Request-Reply pattern where the user waits for a response. To implement this correctly while adhering to platform constraints, the architect must initiate the callout from the User Interface (UI) layer.3

Option C is the correct architectural choice. By using a Lightning component and a button (or a Quick Act4ion), the callout is initiated directly from the user's session. The component calls an Apex controller, which performs the synchronous REST callout to the OMS. This allows the user to receive immediate feedback---such as a 'Success' message or an 'Error' notification from the OMS---directly on the Opportunity page.

Option A is incorrect because Apex Triggers are prohibited from making synchronous callouts. If a trigger initiates a callout, it must be asynchronous (using @future or Queueable Apex), which violates the business requirement for synchronicity. Making a synchronous call from a trigger would block the database transaction and could lead to 'Uncommitted Work Pending' errors or system timeouts. Option B (Batch Apex) is inherently asynchronous and delayed; an hourly job would not provide the real-time, synchronous feedback required during the 'Closed/Won' transition. Therefore, moving the integration logic to a UI-driven button is the only way to satisfy the synchronous requirement while staying within Salesforce's execution and transaction limits.

To translate abstract business needs into a functional Integration Architecture, an architect must move beyond 'what' the business wants to 'how' the data will technically flow. The details in Option B represent the fundamental building blocks of any integration design.

Source and Target Systems: Determining which systems are involved dictates the available APIs (REST, SOAP, Bulk) and required security protocols (OAuth, Mutual SSL).

Directionality: Knowing if the update is unidirectional or bidirectional is critical for record mastering, identifying the 'System of Record,' and preventing infinite data loops.

Data Volume: This is a primary driver for selecting the Integration Pattern. High volumes (millions of records) require the Bulk API, while low-volume, real-time updates are better suited for Streaming or REST APIs.

Transformation Complexity: If data must be heavily massaged or merged from multiple sources, it justifies the need for Middleware (ESB/iPaaS).

Option A focuses on user interface and licensing, which are implementation details rather than architectural integration requirements. Option C deals with project management and resource allocation. While these are important for the project's success, they do not help the architect decide between a Request-Reply or Fire-and-Forget pattern. By focusing on systems, data direction, and volume, the architect ensures that the proposed solution is technically viable, scalable, and adheres to Salesforce platform governor limits.

When data must reside on-premises due to security or compliance policies, but needs to be visible and actionable in Salesforce, the architect should recommend Data Virtualization via Salesforce Connect.

Salesforce Connect allows Salesforce to treat external data as if it were stored natively in the org without ever moving the data into the Salesforce cloud.28 This is achieved by creating External Objects that map to the on-premises data structures. For this to work seamlessly, the on-premises system or a middleware layer must expose the data through a compatible protocol, most commonly the Open Data Protocol (OData).

Option C is incorrect because Salesforce Connect does not natively support ODBC directly; ODBC is a low-level driver protocol, whereas OData is a web-based RESTful protocol designed for cross-platform data exchange. Option B is irrelevant as the data is stated to be on-premises, not in Heroku. By using Salesforce Connect with OData, the architect satisfies the 'stay on-premises' policy while providing Salesforce users with real-time, bidirectional access to the data, supporting features like Global Search and related lists without the overhead of data synchronization.