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

In an org merger scenario, a Salesforce Platform Integration Architect must often design interim solutions that balance speed of delivery with minimal development overhead. The requirement here is for leads to be synced within a 30-minute window. This is a relatively low-latency requirement that does not strictly necessitate a real-time, event-driven architecture, which typically requires more complex infrastructure like Platform Events or middleware.

Option A, calling the Salesforce REST API to insert leads into the target system, represents the standard, most straightforward approach. Since both systems are Salesforce orgs, the retiring org can be configured to make an outbound REST call to the new org's standard Lead endpoint. This can be achieved with a small amount of Apex code (such as a trigger or an invocable method called by a Flow). This approach is considered the "least development effort" because it leverages the standard REST API, which is already enabled and authenticated via a Connected App in the target org. It requires no custom API development in the target system and uses standard JSON payloads.

Option B is incorrect because the Tooling API is intended for managing metadata, system settings, and developer tools, not for standard transactional data movement like Lead insertion. Option C, using the Composite REST API, is an optimization technique designed to group multiple requests into a single call to save on API limits. While efficient for high-volume scenarios, it introduces additional development complexity regarding payload construction and bulk error handling that exceeds the "least effort" requirement for a simple Lead sync. Therefore, a standard REST call is the most direct path to meeting the 30-minute SLA with minimal coding.

When external services are highly volatile (added/removed frequently), the goal is to decouple the Salesforce UI from the underlying service logic. An Integration Architect should propose invoking a middleware service to retrieve the valid shipping methods.

By using middleware (such as an ESB or MuleSoft) as an abstraction layer, Salesforce doesn't need to "know" the details of the 34 different shipping providers. When a sales rep selects a country, Salesforce makes a single callout to the middleware. The middleware then performs the routing logic to identify which shippers are active for that region and returns a standardized list to Salesforce.

Option A is a "maintenance nightmare"; every time a shipping service changes in any of the 34 countries, an admin would need to manually update picklist values and dependencies in Salesforce, which is not scalable. Option C (Platfor31m Events) is an asynchronous pattern unsuitable for a real-time "request-reply" scenario where a rep is waiting for an estimate during a live customer interaction. Utilizing middleware centralizes the logic, simplifies Salesforce configuration, and allows NTO to change shipping providers without any code deployments or metadata updates in the Salesforce org.

In a contract-first integration approach using RAML, the specification acts as the single source of truth for request and response structures. Since Salesforce unit tests are prohibited from performing actual network callouts, the HttpCalloutMock interface must be used to simulate external API behavior.

To ensure unit tests truly confirm adherence to the RAML contract, the architect must mandate that the mock implementation specifically returns responses formatted per the RAML specification. This means the mock's JSON or XML body, headers, and HTTP status codes (e.g., 200 OK, 400 Bad Request) must exactly match the "interface contract" defined in the RAML file.

By strictly aligning the mock with the RAML spec, developers ensure that the Apex client's parsing logic (e.g., JSON.deserialize()) is tested against the agreed-upon data model. If the external service later changes its schema in a way that deviates from the RAML, the unit tests—which are based on that contract—will help identify where the Apex code might fail. Options B and C are technically incorrect: the client does not "call" or "implement" the mock; rather, the test runtime provides the mock instance to the client via Test.setMock().

In this scenario, the primary architectural challenge is managing high-latency, multi-step orchestration involving 10 disparate external systems. Each agency has a varying response time that can span several days, making a synchronous "Request-Reply" pattern within Salesforce technically impossible due to transaction timeout limits (maximum 120 seconds).

The recommended approach is to leverage Middleware as the orchestration and state-management layer. Middleware (such as an ESB or iPaaS) is specifically designed for Process Choreography. Salesforce initiates a single "Fire and Forget" request to the middleware. The middleware then takes responsibility for:

Sequential or Parallel Callouts: Initiating the requests to all 10 verification agencies.

Callback Management: Handling the asynchronous responses from each agency as they arrive over a period of days.

Aggregation Logic: Consolidating the results and determining when the "Business Process" is complete (e.g., all 10 agencies have approved).

Once the consolidation logic is satisfied, the middleware performs a Remote Call-In to the Salesforce REST API to update the trainer’s record. This pattern keeps Salesforce "clean" by moving complex, long-running orchestration logic off-platform, preventing the consumption of excessive Apex CPU time and ensuring that Salesforce only receives a single, final status update.

Option B (External Services) is unsuitable for a multi-day asynchronous process as it is designed for real-time, synchronous Flow actions. Option C (@future) is restricted by the same 120-second timeout and cannot handle the "waiting" state required for days of verification. Using middleware provides the necessary Quality of Service (QoS), durability, and error handling required for such a critical enterprise compliance process.

When proposing Platform Events as an integration mechanism, an architect must ensure that the security model is correctly configured to allow for the publication and subscription of events. Unlike standard objects, Platform Events have specific permission requirements for the "Integration User" or any system entity interacting with the event bus.

For an external system to subscribe to a Platform Event stream (via CometD or the Pub/Sub API), the user account used to authenticate the connection must have the "Read" permission on the specific Platform Event entity. Similarly, if the external system needs to publish events back into Salesforce, the user must have "Create" permissions. These permissions are typically managed through a Profile or a Permission Set assigned to the Integration User.

Regarding the other options, Option A is incorrect because Platform Events are designed for asynchronous communication. They are inherently decoupled; the external system does not need the same uptime as Salesforce. High-volume platform events are stored in the event bus for 72 hours, allowing an external system to "catch up" using a Replay ID once it comes back online. Option C is also incorrect because Platform Events follow a Publish/Subscribe pattern. Salesforce "broadcasts" the event to the bus without needing to know which specific external systems are listening. This decoupling is a primary advantage of event-driven architecture, as it allows for a "one-to-many" distribution model where multiple systems can consume the same message without additional configuration within Salesforce. Thus, ensuring the correct object-level permissions (Read/Create) is the most critical technical consideration for the architect to guarantee successful message delivery.

When a target system experiences prolonged outages (lasting "several days"), point-to-point integrations built directly within Salesforce are prone to failure because they lack the persistence required for long-term retries. The architecturally sound recommendation is to utilize middleware queuing and buffering to "insulate" Salesforce from the target system's instability.

In this architecture, Salesforce sends the order to a middleware layer (such as an ESB or iPaaS). The middleware immediately acknowledges receipt of the message, freeing up Salesforce resources. If the manufacturing system is offline, the middleware stores the order in a persistent Message Queue. Unlike Salesforce Outbound Messaging (Option B), which only retries for up to 24 hours, enterprise middleware can be configured to hold messages for days or even weeks.

Middleware also provides sophisticated Quality of Service (QoS) features, such as "Dead Letter Queues" for manual intervention and customized retry schedules (e.g., retrying every hour instead of every few minutes). This decoupling ensures that Salesforce users can continue to create and "send" orders without seeing technical errors, even while the backend manufacturing system is down. Once the manufacturing service is restored, the middleware "drains" the queue, delivering all buffered orders in the correct sequence. This strategy provides the highest level of reliability and resilience for mission-critical business processes.

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.

Prior to implementing Shield Platform Encryption, the most critical step for an Integration Architect is to perform a comprehensive Review of Shield Platform Encryption configurations and their impact on existing platform functionality. Encryption at rest is not a "set-and-forget" feature; it changes how the Salesforce database interacts with various features, and failing to review these limitations beforehand can lead to significant business disruption.

Salesforce documentation emphasizes that encryption affects several core areas:

SOQL/SOSL Limitations: Encrypted fields have restricted capabilities in WHERE, GROUP BY, and ORDER BY clauses.1 For example, if Social Security Numbers (SSNs) are encrypted using Probabilistic Encryption, they cannot be filtered or sorted in a query.2 This could break existing integrations or reports that rely on finding specific records by SSN.

Search Functionality: While Salesforce supports searching for encrypted data, there are specific behaviors to consider regarding how search indexes are built and updated.

AppExchange and Managed Packages: If the SSN field is used by a third-party app or a managed package, encrypting it might cause those external tools to fail if they are not designed to handle encrypted data types.

Field Attributes: Encrypted fields cannot be used as Unique or External IDs if using the probabilistic scheme, which is a vital consideration for data synchronization architectures.3

Therefore, the architect must first conduct a Business Impact Analysis. This includes identifying where the sensitive data (SSNs) is used in Apex code, Flows, validation rules, and reports. By reviewing the configurations and functional limitations first, the architect can decide between Probabilistic (higher security) and Deterministic (allows filtering) encryption strategies.4 Option A is a step taken during or after implementation (Background Encryption), and Option C is an anti-pattern, as encrypting "everything" leads to unnecessary performance overhead and massive functional loss. Only after a thorough review can the architect safely proceed with the technical implementation of Shield.

When an integration involves financial transactions (payment gateways) and strict audit and reliability requirements, the most robust architectural pattern is to use an Enterprise Service Bus (ESB) or middleware as the orchestration layer.

An ESB provides critical enterprise-grade capabilities that Salesforce cannot easily replicate natively:

Centralized Auditing/Logging: The ESB can capture the full payload of every payment request and response, storing them in a secure log for regulatory compliance and financial audits.

Sophisticated Error Handling: If the payment gateway returns a transient error, the ESB can manage retries or circuit-breaker patterns to prevent system failure.

Protocol Mediation: The ESB can bridge any technical gaps between the Salesforce UI and the external RESTful service.

Option A (External Services) and Option B (Apex Callouts) are point-to-point integrations. While they can facilitate a real-time response, they place the burden of logging, audit trail management, and complex error handling directly on the Salesforce platform. For a B2C enterprise, "hard-coding" these sensitive financial processes into Apex triggers or Flows creates a maintenance challenge and lacks the transparent, enterprise-wide visibility that a middleware solution provides. By routing the payment through an ESB, the architect ensures that the CSR gets their "real-time" confirmation while the company maintains the high level of reliability and accountability required for financial operations.

In the context of data synchronization, reliability during target system outages is a critical requirement. To guarantee that notifications of record changes are stored and available for up to 3 days (72 hours), the architect should recommend Change Data Capture (CDC).

CDC is built on a high-volume event bus architecture. When a change occurs in Salesforce, a change event is published and automatically persisted in the event bus for 72 hours. This 3-day retention window is significantly longer than older technologies like PushTopics, which only retain events for 24 hours.

If the HR system or the integration middleware goes offline, no data is lost. Once the system is restored, the subscriber can retrieve all stored event messages from the bus using a Replay ID. This replayability feature allows the external system to resume processing from exactly where it left off, ensuring that every record update is eventually replicated without the need for manual data exports or custom error-handling logic on the Salesforce side.