Salesforce-Platform-Integration-Architect Dumps Questions With Valid Answers

A.

Use Salesforce external object and OData connector.

Explanation

This scenario presents a classic case for data virtualization rather than data replication. The requirements for real-time creation and viewing of up-to-date order information, combined with the constraints of minimal code and developer resources, make External Objects the most suitable solution.

Let's analyze why this is the correct choice and why the others are not:

A. Use Salesforce external object and OData connector. This is the correct approach. This solution allows you to:

View Real-Time Data (Requirement 3):
Sales reps can see order history and current order status directly in Salesforce as if the data were stored locally, but it's actually fetched in real-time from the external order system via the ESB.

Create Orders in Real-Time (Requirement 1):
By using an OData service exposed by the ESB, you can create an "External Data Source" in Salesforce. You can then define the order and line item tables as External Objects. Using the standard UI or quick actions, sales reps can create new orders, which will be sent in real-time to the external system via the OData connector.

Minimal Customization (Requirement 2):
This approach is largely declarative. It uses the standard Salesforce OData connector and point-and-click setup to define external objects, requiring little to no Apex code.

Run Reports (Requirement 4):
External Objects can be used in Salesforce Reports, allowing managers to run reports on daily/monthly order volumes and fulfillment timelines. The data is queried live from the external system.

Why the other options are incorrect:


B. Use Salesforce custom object, custom REST API and ETL.
This is incorrect. While a custom REST API on the ESB is a good practice, using ETL (Extract, Transform, Load) is a batch process, which violates the real-time requirement for both creating orders (Req 1) and viewing the most up-to-date status (Req 3). Storing the data in custom objects also means it can become stale, and it duplicates data, increasing storage costs.

C. Use Salesforce standard object, REST API and ETL.
This is incorrect for the same reasons as option B. Using standard objects like Opportunity or a custom standard object doesn't change the core problem: ETL is for batch synchronization�, not real-time interaction. It does not meet the real-time requirements.

D. Use Salesforce big object, SOAP API and Dataloader.
This is incorrect. Big Objects are designed for archiving and analyzing massive volumes of historical data (billions of records). They are not suitable for active, transactional processes like creating and viewing current orders. Using Data Loader is a manual, batch-oriented tool, which completely fails the real-time requirement.

Key Concept
The key concept here is Data Virtualization vs. Data Replication.
Data Replication (Options B, C, D):
This involves copying data from the external system and storing it within Salesforce. This leads to data duplication, potential staleness, and the overhead of managing ETL jobs to keep the data in sync.
Data Virtualization (Option A):
This leaves the data in its source system (the on-premise order management system) and provides a virtual "window" to it from within Salesforce using External Objects. This ensures data is always current, avoids data duplication, and is perfectly suited for real-time access scenarios with minimal code.

Reference
This approach is based on the official Salesforce integration pattern known as "Virtual Data Integration with External Objects." The Salesforce documentation for External Objects and the OData connector explicitly supports this use case, allowing for real-time read and write (create) operations on external data without storing it in Salesforce. This pattern is ideal when you need to access data in real-time from an external system that remains the system of record.

B.

Use External Services feature to integrate gateway to Salesforce ensuring realtimeupdates the CSR and support post payment processes.

Explanation

A CSR must submit credit card details via Salesforce to an external REST payment gateway, wait for confirmation, then upgrade the service. The integration demands real-time response, reliable callouts, and audit logging. It’s a synchronous, user-driven flow requiring immediate feedback before proceeding — all within Lightning UI for the CSR.

✅ Correct Option: B. Use External Services feature
External Services lets you register the payment gateway’s OpenAPI schema and generate Apex actions for callouts — no hand-coded HTTP.
Callouts are synchronous, so CSR gets real-time success/failure before upgrading.
Request/response payloads are auto-logged in Setup → External Service Calls for audit.
Supports Flow/Lightning actions — perfect for CSR screen flow with wait-for-confirmation.

❌ Incorrect Option: A. Custom Apex Callout
Building manual HttpRequest/HttpResponse works but requires custom logging (e.g., Platform Events, Custom Objects).
Higher dev effort; no built-in audit trail unless explicitly coded.
Risk of governor limit issues and maintenance overhead — External Services is the declarative alternative.

❌ Incorrect Option: C. Callout through ESB
An ESB (Enterprise Service Bus) adds middleware — unnecessary complexity for a simple REST callout.
Introduces latency, extra cost, and single point of failure.
CSR needs direct real-time response — ESB is overkill and breaks synchronous flow.

❌ Incorrect Option: D. Platform Events
Platform Events are asynchronous and event-driven — CSR cannot wait for payment confirmation.
No native support for calling external REST APIs; requires triggers + callouts (complex).
Designed for decoupled publishing, not request-response with user wait time.

📚 Reference
Salesforce Help – External Services
External Services Call Logs

B.

Can the fulfillment system make a callback into Salesforce?

D.

Is the product catalog data identical at all times in both systems?

Explanation

When planning a Salesforce-to-fulfillment system integration for sending orders, the Integration Architect must focus on data synchronization, system capabilities, and interaction patterns. The two most critical questions are B and D, as they directly impact integration design, reliability, and data consistency.

B. Can the fulfillment system make a callback into Salesforce?
Why this is correct:

Many fulfillment workflows require bidirectional communication.
Example: After receiving an order, the fulfillment system may need to update order status (e.g., “Shipped”, “Backordered”) or send tracking numbers back to Salesforce.

If callbacks are supported, the architect can design asynchronous updates using:
REST/SOAP APIs from fulfillment → Salesforce
Platform Events or Outbound Messages (if Salesforce initiates)
Apex Callouts + Named Credentials
If not supported, the solution must rely on polling, batch sync, or middleware (e.g., MuleSoft, Boomi), increasing complexity and latency.
This question determines whether real-time status sync is feasible — a common business requirement.

D. Is the product catalog data identical at all times in both systems? Why this is correct:

Orders reference Product SKUs, Prices, Descriptions, Taxes, etc.
If catalog data diverges (e.g., price changes in Salesforce but not in fulfillment), it leads to:
Rejected orders
Pricing disputes
Reconciliation issues

The architect must clarify:
Which system is the source of truth for products?
Is real-time sync needed (via API, Platform Events, CDC)?
Or is nightly batch sync acceptable?

This drives decisions on:
Master Data Management (MDM)
Data mapping and transformation
Error handling for mismatches

Mismatched catalog data is one of the top causes of integration failures in order-to-fulfillment scenarios.

Why the other options are incorrect:

A. Can the fulfillment system create new addresses within the Order Create service?

This is a secondary detail, not a planning priority.
Address creation is typically handled in Salesforce (source of truth for customer data).
Even if supported, it’s a feature, not a core architectural decision.
This comes up during API contract design, not initial planning.

C. Can the fulfillment system implement a contract-first Outbound Messaging interface?

Outbound Messaging is a Salesforce-specific push mechanism using SOAP.
It requires the external system to host a public SOAP endpoint — rare in modern APIs.
Most fulfillment systems expect REST, not SOAP.
Contract-first applies to WSDL, but Outbound Messaging is Salesforce-initiated, not a mutual contract.
Better alternatives: Platform Events, Apex REST callouts, or middleware.
This is a tactical implementation question, not a strategic planning one.

References:
Trailhead – Integration Architect:
Plan Your Integration → “Ask: What data needs to flow in which direction?”
https://trailhead.salesforce.com/content/learn/modules/integration-architect-planning
Salesforce Integration Patterns:
Remote Process Invocation – Request and Reply vs Fire and Forgethttps://architect.salesforce.com/design/decision-guides/remote-process-invocation
Data Synchronization Best Practices:
https://help.salesforce.com/s/articleView?id=sf.integration_data_synchronization.htm

A.

Data Visualization

Explanation

The core requirement is to allow users to view and update data in Salesforce that is physically stored only in an external system. This demands a real-time, virtual integration where Salesforce acts as a UI layer, but the external system remains the single source of truth. The solution must support two-way, immediate communication without replicating and storing the order data within the Salesforce database.

✅ Correct Option

A. Data Visualization
This is the correct pattern. Data Visualization involves displaying data from an external system in Salesforce UI in real-time without storing it in the Salesforce database. Tools like Salesforce Canvas or direct UI-based callouts can be used to embed the external order management application's interface directly within a Salesforce page. This allows reps to view and update orders, with all data persistence and logic handled by the remote system, fulfilling the requirement perfectly.

❌ Incorrect Options

B. Data Synchronization
This pattern involves copying and storing data in two or more systems to keep them consistent. It directly violates the key requirement that data "only persist in the external system," as it would require creating and storing Order objects in Salesforce, which would then be synchronized with the external system.

C. Process Orchestration
This pattern focuses on coordinating a long-running business process across multiple systems. While an orchestration might use the real-time visualization, the pattern itself is about managing the process flow, not the specific UI requirement for viewing and updating data without persistence.

D. Batch Processing
This pattern is for moving large volumes of data at scheduled intervals (e.g., nightly). It does not support the "real-time" requirement for sales representatives to view and update information immediately while interacting with a customer.

📚 Reference
For official guidance, refer to the Salesforce Integration Patterns & Practices documentation on the Salesforce Architect website. The "Data Visualization" pattern is specifically described as a method for displaying and interacting with external data in the Salesforce UI without storing it locally, which aligns with the requirement for the external system to be the sole system of record.

B.

Use continuation to process payment to the payment gateway.

Explanation

The core requirements are:
The transaction is initiated by a student (Community user) and must feel synchronous (i.e., the student must wait for the result).
The processing time is more than 30 seconds.
The student needs the result in real-time to retry the payment if an error occurs.
Salesforce Apex has a standard synchronous callout timeout limit of 10 seconds. Since the payment gateway takes over 30 seconds, a standard synchronous callout will fail with a timeout exception.
Continuation is the specific Salesforce framework designed to handle long-running external web service requests that are initiated from a Visualforce Page or a Lightning Component (LWC), which is typically used in a Community.

The Continuation pattern splits the single transaction into two parts:
The Apex method calls the external service and immediately returns a Continuation object, releasing the user's thread so the transaction doesn't time out.
The external service processes the payment (taking >30 seconds).
When the response is received, a callback method is automatically executed to process the result and update the student's Community page with the real-time success or error status, allowing for a retry.
This approach preserves the synchronous user experience (the user waits on the page) while bypassing the strict 10-second synchronous governor limit.

❌ Why other options are incorrect:

A. Use platform event to process payment...:
Platform Events (a Publish/Subscribe pattern) are purely asynchronous. They would initiate the payment, but the student's screen would immediately refresh without a result. The student would need to wait for a separate mechanism (like a push topic or polling) to get the result, which fails the requirement for a real-time, immediate result allowing for a retry.

C. Use change data capture (CDC) to process payment...:
CDC is an asynchronous pattern used to notify external systems when a record in Salesforce is changed. It is the wrong tool for initiating a payment request from a Community user and expecting a real-time response.

D. Use request and reply to make an API call...:
This is the integration pattern (Remote Process Invocation—Request and Reply), but it doesn't specify the technical solution to overcome the 30-second timeout. A standard Apex API call would be a synchronous Request and Reply, which would fail due to the 10-second limit. The Continuation framework (Option B) is the specific technical implementation of the Request and Reply pattern for long-running transactions.

🌐 Reference
Salesforce Documentation: Make Long-Running Callouts with Continuations
Maximum Synchronous Timeout: Standard synchronous callouts timeout after 10 seconds.
Continuation Purpose: Continuations are designed to enable an Apex application to make long-running requests (up to 120 seconds) to an external Web service and integrate the results into the user interface (Lightning Components/Community) without exceeding the cumulative transaction timeout.