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 building custom mobile or web applications that aim to replicate the look and feel of Salesforce Lightning Experience , the User Interface (UI) API is the architecturally recommended choice.

The UI API is specifically designed to provide the metadata and data needed to build high-fidelity user interfaces. Unlike the standard REST API (Option B), which returns raw record data, the UI API returns both data and metadata in a single response. This includes information about page layouts, field-level security, picklist values, and localized labels. By using the UI API, the mobile app can dynamically render fields according to the user ' s permissions and the organization ' s layout configurations, ensuring that the custom app stays in sync with changes made in Salesforce Setup without requiring code updates in the mobile app.

Connect REST API (Option A) is primarily used for Chatter, Communities (Experience Cloud), and CMS content, and while it is useful for those specific social features, it does not provide the layout and record-level metadata required for a full CRM interface. The UI API is the same underlying technology that powers the Salesforce mobile app and Lightning Experience itself. Therefore, utilizing this API allows NTO ' s developers to build a native app that perfectly mimics the Lightning Experience while reducing the amount of custom logic needed to handle complex Salesforce UI requirements.

The Bulk API is designed to process massive datasets by breaking them into smaller batches that Salesforce processes asynchronously. When a batch fails with the “Max CPU time exceeded” error, it typically indicates that the complexity of the operations triggered by the record—such as Apex triggers, Flows, or complex sharing calculations—exceeds the 10,000ms limit within a single transaction.

Reducing the batch size is the standard architectural remedy because it reduces the number of records processed in a single transaction, thereby lowering the total CPU time consumed by those records. However, the architect must consider the impact on the overall throughput and execution time .

When batch sizes are smaller, the total number of batches required to process the same dataset increases. For instance, moving from a batch size of 2,000 to 200 for a 1-million-record dataset increases the number of batches from 500 to 5,000. Each batch carries its own overhead for initialization and finalization within the Salesforce platform. Consequently, while the individual batches are more likely to succeed, the total time required to complete the entire job will increase.

The architect should also be aware of the daily limit on the total number of batches allowed (typically 15,000 in a 24-hour period). While Option C mentions API request limits, the Bulk API is governed more strictly by its own batch limits. Option B is less likely because " parallel mode " naturally manages concurrency. Thus, the primary trade-off the architect must present to the business is a gain in reliability (successful processing) at the cost of total duration (increased sync time).

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 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.

To meet the requirements of minimal customization, low developer resources, and real-time visibility without data replication, the architect should utilize Salesforce Connect with External Objects and an OData connector.

Salesforce External Objects allow the OMS data to be viewed within Salesforce as if it were stored natively, but the data remains in the on-premise system. This fulfills the requirement for sales reps to see " up-to-date information " because every time they view the record, Salesforce Connect fetches the latest data via the ESB ' s OData endpoint. This Data Virtualization pattern is the most efficient choice for real-time history where users only need to view the data occasionally.

Options A and B involve Data Replication via ETL, which would store the order data inside Salesforce. Given the volume (15,000 orders/shift with 25 line items each = 375,000 records daily), this would rapidly consume Salesforce data storage limits and require significant custom development for the ETL logic and REST APIs. Furthermore, ETL is typically batch-oriented and would not provide the true " real-time " view requested. By using an OData connector, the architect leverages a declarative, " no-code " solution that satisfies the timeline constraints and provides immediate access to order details and line items without the cost of data storage.

When a target system experiences prolonged outages (lasting " several days " ), point-to-point integration solutions built within Salesforce are likely to fail or reach their retry limits. For example, Salesforce Outbound Messaging (Option B) only retries for up to 24 hours before dropping the message.

The architecturally robust solution is to introduce a Middleware layer (ESB or iPaaS) that provides queuing and buffering . In this model, Salesforce sends the order to the middleware. The middleware immediately acknowledges receipt (preserving Salesforce performance). If the manufacturing system is offline, the middleware stores the message in a persistent queue.

Middleware is designed for this high level of Quality of Service (QoS) . It can be configured with custom retry logic—such as waiting 30 minutes between attempts—and can hold millions of messages for days or even weeks. This effectively " insulates " Salesforce from the manufacturing system ' s instability. Option C is overly complex and requires custom development in both the event bus and Apex, whereas middleware provides this functionality as a native capability. By using middleware, the architect ensures that no orders are lost during extended manufacturing downtime and that the integration is decoupled and resilient.

When an organization must interact with multiple external services (34 different shipping providers) that change frequently, the primary architectural goal is to decouple Salesforce from the specific endpoints and protocols of those services. 11

The architect should propose us 12 ing middleware to abstract the call . By introducing a middleware layer (such as an ESB or iPaaS), Salesforce makes a single, standardized call to the middleware, passing the country and order details. The middleware then handles the " Process Orchestration " :

Service Routing: Determining which shipping service is valid for the specified country.

Protocol Mediation: Translating the standard Salesforce request into the specific format (REST, SOAP, XML, etc.) required by each individual shipping provider.

Maintenance: When a shipper is added or removed, the change is made in the middleware without requiring any code or metadata updates in Salesforce.

Option A (Picklists) creates a high administrative burden and does not solve the underlying technical complexity of making callouts to dozens of different APIs. Option B (Platform Events) is asynchronous and would introduce unnecessary latency for a sales rep who needs an estimate " on the spot " to complete an order. Middleware abstraction provides a scalable, maintainable, and agile architecture that allows NTO to optimize its shipping operations without disrupting the CRM user experience.

Securing outbound integrations from Salesforce requires protection at both the authentication and transport layers. Named Credentials and Two-way SSL (Mutual Authentication) together provide a robust security posture for reading external data via HTTP.

Named Credentials serve as a secure management tool for callout endpoints. They abstract the endpoint URL and the necessary authentication parameters (such as Basic Auth or OAuth tokens) away from the Apex code. This separation ensures that sensitive credentials are not hardcoded and can be easily updated in one central location if the endpoint or credentials change.

Two-way SSL (Mutual TLS) provides transport-layer security by requiring both the client (Salesforce) and the external server to authenticate each other using digital certificates. While standard SSL verifies the server to the client, Two-way SSL ensures that the external system only accepts requests from a verified Salesforce org. This " Mutual TLS " setup is highly recommended for enterprise-level integrations where proof of the caller ' s identity is as critical as the encryption of the data in transit. By combining these two methods, the architect ensures that the integration is secured against both credential theft and unauthorized server access.

For a team with limited development resources and a low-code requirement, Lightning Flow (Flow Builder) is the primary declarative engine for modern integrations.

In this scenario, creating a Platform Event via a record-triggered flow provides a highly scalable, near real-time " Fire-and-Forget " signal to the middleware. This is considered low-code because it can be built entirely using point-and-click tools within Salesforce. Once the Order is created, the flow publishes the event to the bus. The middleware, acting as a subscriber, receives the event and orchestrates the REST call to the ERP.

Option C ( Outbound Messaging ) is also a low-code tool, but it natively sends messages in SOAP format. Since the ERP requires a REST endpoint , using Outbound Messaging would necessitate additional transformation logic in the middleware, making it a less efficient architectural choice than using a Flow to trigger an event or an External Service. Option B ( Change Data Capture ) is a powerful tool but often requires more advanced " pro-code " configuration on the subscriber/middleware side to handle Replay IDs and Bayeux protocols, which might exceed the " limited resources " constraint of the Salesforce team.