Pass the Salesforce Integration Architecture Designer Integration-Architect Questions and answers with Dumpstech

When comparing Platform Events and Outbound Messaging for a near-real-time architecture, a Salesforce Platform Integration Architect must evaluate fundamental differences in their delivery models and governance. While both provide declarative, asynchronous "Fire-and-Forget" capabilities, their technical constraints differ significantly, particularly regarding scalability and platform limits.

The key architectural highlight in this scenario is that Platform Events operate on a specialized event bus with specific Event Publishing and Event Delivery limits. Unlike Outbound Messaging, which is governed by more general daily outbound call limits (often tied to user licenses), Platform Events have a dedicated allocation for the number of events that can be published per hour and delivered in a 24-hour period to external clients via the Pub/Sub API or CometD. For example, the number of concurrent subscribers to a Platform Event channel is typically capped at 2,000 for standard configurations. Since the customer expects 3,000 customers to view these messages, this limit is a critical evaluation point; the architecture would need to account for this gap, perhaps by using middleware to fan out messages to the larger audience.

In contrast, Outbound Messaging does not have an "Event Delivery" limit in the same sense. It is a point-to-point SOAP-based push mechanism where Salesforce manages retries for up to 24 hours if the receiving endpoint is unavailable. However, it is less flexible for multi-consumer scenarios because it requires a separate configuration for every unique destination.

Regarding the other options: Option A is incorrect because neither system strictly guarantees "exactly-once" delivery without the possibility of duplicates; in fact, Outbound Messaging may deliver a message more than once if it doesn't receive a timely acknowledgment. Option B is incorrect because Platform Events do not have built-in "fault recovery" handled by Salesforce in the same way as Outbound Messaging's automatic retry queue; with Platform Events, it is the subscriber’s responsibility to use a Replay ID to retrieve missed events within the 72-hour retention window. Therefore, highlighting the unique delivery and publishing limits is the most vital step for the architect.

In the "Discovery" phase of integration architecture, the architect must translate abstract business needs into technical requirements. The most critical variables that define the Integration Pattern are Timing and Volume.

An architect cannot choose between the REST API, Streaming API, Bulk API, or Outbound Messaging without knowing:

Latency Requirements: Does the business need the update in 200 milliseconds (Synchronous), 2 minutes (Near Real-Time), or 24 hours (Batch)?

Frequency: Is the data updated every time a user clicks a button, or once at the end of the day?

Volume: Are we moving 10 records at a time or 10 million?

Option A focuses on UI/UX and licensing, which are project management concerns. Option B focuses on resource allocation and governance. While important for the project, they do not inform the technical design of the data flow.

By specifically seeking out Timing aspects (Synchronous vs. Asynchronous) and Update Frequency, the architect can apply the Salesforce Integration Decision Matrix. For instance, a "Real-time" requirement for small volumes leads to a Request-Reply pattern via Apex Callouts. A "Nightly" requirement for large volumes leads to a Batch Data Synchronization pattern via the Bulk API. Identifying these "Non-Functional Requirements" (NFRs) early is the only way to ensure the architecture is scalable and stays within platform governor limits.

For outbound integrations from Salesforce to an external cloud gateway like Microsoft Azure API Gateway, securing the communication at the transport layer is a fundamental requirement. While standard SSL provides one-way encryption where the client (Salesforce) verifies the server (Azure), Mutual Server Authentication (Two-Way SSL/TLS) ensures that both parties are verified before data is exchanged.

In this architecture, Salesforce presents a digital certificate to the Azure API Gateway during the TLS handshake. For production environments, Salesforce architects recommend using certificates signed by a Certification Authority (CA) rather than self-signed certificates to establish a trusted chain of identity that complies with enterprise security standards. This mechanism prevents unauthorized clients from connecting to the Azure endpoint, effectively mitigating man-in-the-middle attacks and unauthorized data exfiltration.

While a Connected App and OAuth (Option B) are essential for inbound requests where external systems call Salesforce, they do not natively secure the point-to-point connection when Salesforce acts as the client. Similarly, a federated API access model (Option A) focuses on user identity but does not address the transport layer security between the two cloud platforms. By configuring two-way SSL, Northern Trail Outfitters ensures that the Azure API Gateway only processes requests originating from a trusted, authenticated Salesforce instance, fulfilling the high security and trust requirements of modern integration architecture.

To minimize downtime when an external endpoint changes, an Integration Architect must ensure that the URL is not "hardcoded" within Apex code or configuration. The standard Salesforce mechanism for abstracting and managing external endpoints is Named Credentials.

Named Credentials specify the URL of a callout endpoint and its required authentication parameters in one definition. If the URL changes, an administrator simply updates the "URL" field in the Named Credential setup. This change takes effect immediately across all Apex callouts, Flows, and External Services that reference it, without requiring a code deployment or a sandbox-to-production migration.

Along with Named Credentials, Remote Site Settings (or the more modern External Website Configurations) are required. Salesforce blocks all outbound calls to URLs that are not explicitly whitelisted.

By having both in place, the remediation process is:

Update the URL in the Named Credential.

Update (or add) the new URL in the Remote Site Settings.

This approach follows the "Separation of Concerns" principle. Option B (ESB) could technically handle this, but it adds an extra layer of failure and complexity for a simple URL change. Option C (Content Security Policies) is used to control which resources (like scripts or images) a browser is allowed to load in the UI; it does not govern server-side Apex callouts. Therefore, the combination of Named Credentials and Remote Site whitelisting is the most efficient and standard way to provide architectural agility and minimize downtime.

In a Remote-Call-In or Batch Synchronization pattern where an external middleware initiates the connection to Salesforce, the external system must be authenticated. The standard Salesforce framework for this is the Connected App.

A Connected App provides a framework for external applications to integrate with Salesforce using APIs and standard protocols like OAuth 2.0. For a high-volume (100,000 records) batch process initiated by middleware every 6-12 hours, the architect would recommend a Connected App using a secure flow, such as the OAuth 2.0 JWT Bearer Flow. This allows the middleware to authenticate as a specific "Integration User" without storing clear-text passwords.

Option A (API Gateway) is used to manage and secure outbound calls from Salesforce or between external services; it does not handle inbound authentication to the Salesforce org itself. Option B (Remote Site Settings) is a whitelist configuration used purely to allow Salesforce to make outbound callouts to a specific URL; it provides no authentication mechanism for systems calling into Salesforce. By recommending a Connected App, the architect ensures that the middleware has the necessary permissions (scopes) to use the Bulk API—which is the appropriate mechanism for the 100,000 record volume—while maintaining a secure, auditable, and standard integration boundary.

The requirement for an agent to receive a newly created bank account ID in real time to inform a customer signifies a synchronous dependency. The agent cannot complete the business process until the core banking system confirms the account creation and returns the generated identifier.

The Request and Reply pattern is the appropriate recommendation for this use case. In this pattern:

Request: Salesforce sends a synchronous callout (REST or SOAP) containing the customer's data to the core banking system.

Wait: The Salesforce thread remains open, and the user interface typically displays a loading indicator while waiting for the external system to process the request.

Reply: The core banking system returns the new account ID, which is then immediately displayed to the support agent in Salesforce.

Options A (Platform Events) and C (Streaming API) are asynchronous, event-driven patterns. While highly scalable, they are unsuitable for this specific "on the spot" requirement because there is no native way to force the agent's screen to wait for an asynchronous callback with the new ID. Request and Reply ensures that the agent has the necessary information to complete the customer interaction in a single, continuous flow.

In the framework of a Salesforce Platform Integration Architect's landscape evaluation, the primary goal is to determine the "system of record" for each business function and identify redundancies between legacy systems and the proposed Salesforce architecture. This process is driven by the alignment of Salesforce's native "Customer 360" capabilities with the specific goals defined by the enterprise stakeholders.

According to Goal 2, the customer intends to leverage Salesforce specifically for marketing, sales, and service processes. Within the standard Salesforce ecosystem, these domains are addressed by the three core cloud products:

Marketing Cloud provides the capabilities found in the legacy Email Marketing System.

Sales Cloud replaces the functions of the Sales Activity System.

Service Cloud is the native replacement for the Case Management System.

By migrating these three domains to a single platform, the organization directly fulfills Goal 1—developing a 360-degree view of the customer. Consolidating these interactions onto the Salesforce platform allows for a unified data model where customer behaviors in marketing, sales, and support are visible in one place, eliminating the silos inherent in the previous landscape.

However, a critical constraint is presented in Goal 3, which explicitly mandates the reuse of existing enterprise capabilities for quoting and order management. In an integration architecture, this signals that the Quoting System and Order Management System (OMS) are designated as external systems of record that must remain active. These systems often contain complex logic, tax calculations, or supply chain integrations (such as with an SAP Business Suite) that the business is not currently ready to migrate.

Therefore, since the Quoting and Order Management systems must be retained, they are excluded from the retirement list. The remaining three systems—Email Marketing, Sales Activity, and Case Management—overlap with Salesforce's native strengths and are not protected by the "reuse" requirement. Retiring them streamlines the technology stack and allows the architect to focus on building robust integration patterns (such as REST or SOAP callouts) to connect Salesforce to the retained Quoting and Order Management systems.

To satisfy a requirement for near real-time updates to an ERP system while adher9ing to a low-code constraint, the architect must leverage Salesforce's modern declara10tive automation tools. The goal is to initiate an outbound signal that the existing middleware can then orchestrate and deliver to the ERP's REST endpoint.

The Remote Process Invocation—Fire and Forget pattern is perfectly suited for this scenario. In this pattern, Salesforce sends a message to an external system and does not wait for a functional response. This is ideal for "capturing" transactions in an ERP where the primary goal is record synchronization rather than a real-time calculation return. By using Flow Builder, the team can implement a record-triggered flow on the Order object. This flow can be configured to execute "Actions" that send data to the middleware via External Services or standard HTTP Callouts (Beta/GA features in modern Flow), which requires zero Apex coding.

Option B, Outbound Messaging, is a legacy declarative tool that is highly reliable but has a significant limitation: it natively sends messages in SOAP format. Since the requirement specifically specifies a REST endpoint, using Outbound Messaging would require additional transformation logic in the middleware, making it a less direct architectural fit than a modern Flow-based REST call. Option C, Change Data Capture (CDC), is a highly scalable, event-driven mechanism, but it is typically considered more complex to implement and maintain. It requires the middleware to manage "Replay IDs" and subscribe to a streaming channel, which often requires more specialized development effort on the middleware side compared to a simple HTTP POST from a Flow. For a team with limited development resources, Flow Builder provides the most accessible and maintainable path to achieving near real-time integration.

When utilizing the Bulk API, the platform breaks large datasets into manageable "batches" for asynchronous processing. The "Max CPU time exceeded" error occurs when the synchronous logic triggered by the record save—such as Apex triggers, Flows, or complex sharing calculations—exceeds the 10,000ms limit within a single batch transaction.

Reducing the batch size is the standard technical remedy; it reduces the number of records processed in one transaction, thereby lowering the cumulative CPU time per batch. However, the Integration Architect must account for the latency impact on the end-to-end job completion.

As the batch size decreases, the total number of batches increases significantly. For example, moving from a batch size of 2,000 to 200 for a 1-million-record load increases the number of batches from 500 to 5,000. Each batch incurs a platform overhead for initialization, finalization, and queuing. Consequently, the total time required to execute the bulk job will increase because more time is spent on administrative platform overhead and queuing cycles rather than data processing.

The architect must also monitor the Daily Bulk Batch Limit (typically 15,000 batches per rolling 24-hour period). While a smaller batch size helps avoid CPU timeouts, it moves the system closer to this daily consumption limit. Option B is less relevant as "parallel mode" is designed to handle concurrency within its own defined limits, and Option C refers to synchronous REST/SOAP limits rather than the asynchronous Bulk API limits. Therefore, the primary trade-off is improved reliability (successfully processed records) at the cost of throughput/speed.