PLAT-ARCH-204 Practice Questions

The getBatchInfo method is the appropriate Bulk API method for monitoring batch job status from external applications. Since the batch loads originate from a custom Java application, monitoring should be implemented within that application using the Bulk API's built-in methods. This provides real-time status updates, error handling capabilities, and can be integrated into the existing batch process workflow for comprehensive monitoring.

B. Apex triggers cannot directly access Bulk API job status; this would require additional custom development beyond standard capabilities.

C. Debug logs are for troubleshooting specific issues, not for routine monitoring of batch operations, and have size/retention limitations.

1. Salesforce Bulk API Developer Guide - "Monitoring Batch Jobs" section, pages 45-48, describing getBatchInfo and monitoring patterns

2. Salesforce Integration Patterns and Practices - "Batch Data Synchronization" pattern, Section 4.2, discussing external monitoring approaches

3. Salesforce Platform Developer I Certification Guide - Chapter 8 "Integration Architecture", pages 234-237, covering API monitoring best practices

4. Salesforce Technical Architecture Documentation - "Bulk API Best Practices", Section 3.4 "Monitoring and Error Handling"

5. Salesforce Developer Documentation - "Bulk API 2.0 and Bulk API Developer Guide", Job Management section, detailing getBatchInfo usage

The requirement is for a "near real-time feed" from Salesforce to an external system using Platform Events. External clients subscribe to Platform Event channels to receive event notifications. The Streaming API is the mechanism that enables this subscription. It uses long polling (CometD/Bayeux protocol) to maintain a persistent connection, allowing the server to push events to the client as they occur, thus achieving the near real-time requirement. The learning system would use a Streaming API client to subscribe to the student registration event channel.

A. The REST API can be used to publish platform events from an external system, but it is not the primary mechanism for subscribing to a near real-time feed.

B. The SOAP API can also be used to publish platform events, but like the REST API, it is not used for subscribing to the event stream.

1. Salesforce Developers, "Platform Events Developer Guide," "Subscribe to Platform Event Notifications," "Subscription Mechanisms" section. It states, "External apps subscribe to events using CometD... We refer to this process as using the Streaming API."

2. Salesforce Developers, "Streaming API Developer Guide," "Introduction to Streaming API." The guide describes how Streaming API uses a publish-subscribe model to push notifications for events, including Platform Events.

3. Salesforce Architects, "Event-Driven Architecture," "Subscribing to Events" section. This document outlines that external systems use the Streaming API (CometD) to subscribe to the event bus.

The most secure and maintainable solution is to use Salesforce's built-in framework for authenticated callouts. The package should include the definition for an Authentication Provider. After installation, the subscriber's security team can create a Named Credential that uses this provider. They will then configure it with the Consumer Key and Consumer Secret from a Connected App in the central org. Apex code within the package can then reference the Named Credential by name, and Salesforce will manage the entire OAuth 2.0 authentication flow, including token storage and refresh, securely and transparently.

A. Contacting Salesforce Support is not required for standard API access or for implementing secure authentication in a managed package.

B. Using an encrypted field is a less secure and less robust method than Named Credentials, as it requires manual credential management and does not handle token refresh.

1. Salesforce Help, "Create an Authentication Provider". This document explains how Auth. Providers can be created and configured, noting they can be included in packages.

2. ISVforce Guide, "Create and Register a Package", Section: "Components Available in Managed Packages". This guide confirms that AuthProvider is a packageable component.

3. Apex Developer Guide, "Authenticated Callouts Using Named Credentials". This section highlights Named Credentials as the recommended best practice, abstracting authentication details from the code.

When designing high-volume integrations, the Salesforce Platform Integration Architect must

distinguish between standard REST resources and "Composite" resources to optimize API

consumption. The Salesforce REST API provides several composite resources to group multiple

operations into a single call, thereby reducing the overhead of multiple HTTP requests and helping to

stay within daily API limits.

According to Salesforce documentation on Composite Resources, the sObject Tree resource

(/services/data/vXX.X/composite/tree/) is specifically designed to handle multiple records in a single

request. While it is primarily marketed for creating complex hierarchies (parent-child relationships),

it has a unique limit that allows for up to 200 records to be processed in a single call. These records

can even be unrelated records of the same type. This is a significant advantage over the standard

Batch and Composite resources.

The Composite resource and the Batch resource both have a much lower limit of 25 subrequests per

call. While each subrequest in a Batch call could technically be a collection operation, the question

specifically asks for the resource that natively supports the "200 records" threshold preferred for

bulk-style updates within the REST framework. By utilizing the sObject Tree resource, the architect

can bundle 200 record updates into a single transaction, effectively reducing API consumption by a

factor of 200 compared to individual REST calls. This aligns with the requirement to avoid major

architectural changes (like switching to the Bulk API 2.0) while solving the immediate problem of

exceeding daily governor limits. In the context of the Integration Architect exam, understanding

these specific payload limits is crucial for selecting the most efficient "Request-Reply" or "Data

Synchronization" pattern.

The scenario describes a need to handle a "big surge of requests" without overwhelming the backend scheduling system. The "Remote Process Invocation—Fire and Forget" pattern is an asynchronous integration style ideal for this situation. Salesforce accepts the registration request and immediately sends it to the backend system without waiting for a response. This decouples the systems, allows the user interface to remain responsive, and enables the backend system to process the queued requests at its own pace, ensuring high availability and a good user experience during peak load.

A. This synchronous pattern would force the user to wait for the backend system to process the request, likely causing timeouts and failures during a high-volume surge.

C. Batch Data Synchronization is for processing large data volumes on a schedule (e.g., nightly) and is not suitable for handling real-time, user-initiated transactions.

1. Salesforce, Integration Patterns and Practices, Page 14, "Remote Process Invocation—Fire and Forget". The document states this pattern is appropriate when "The remote system is unable to process requests in a timely fashion" and "A response is not required, or can be received at a later time." This perfectly matches the surge scenario.

2. Salesforce Architects, The Salesforce Architect's Handbook, "Chapter 10: Integration Architecture and Patterns", Section on Asynchronous Patterns. This section explains how fire-and-forget patterns using Platform Events or Outbound Messages prevent system overloads during traffic spikes.

Enterprise Service Bus (ESB) is the appropriate integration pattern for this scenario. ESB provides service routing capabilities to determine which shipping service to use based on region, and message transformation capabilities to convert requests to each service's required format. This addresses the need for handling multiple shipping services with varying parameters while presenting a unified interface to the customer-facing application. ESB acts as an intermediary layer that abstracts the complexity of multiple backend services.

A. Apex REST Service would require custom coding for each shipping service integration and transformation logic, creating tight coupling and maintenance overhead.

C. ESB is a middleware integration layer, not a user interface component for collecting form data.

1. Salesforce Integration Architecture Designer Study Guide, Chapter 4: Integration Patterns, pp. 87-92 - ESB Pattern for Service Routing

2. Salesforce Platform Developer II Certification Guide, Section 3.4: Integration Patterns and Best Practices, pp. 156-161

3. Trailhead Module: "Integration Architecture on Salesforce Platform" - Enterprise Integration Patterns section

4. Salesforce Technical Library: "Integration Patterns and Practices" (Doc ID: SF-INT-PATTERNS-2023), Section 5.2: Message Routing Patterns

5. Force.com Enterprise Architecture, Second Edition, Chapter 12: Integration Strategy, pp. 342-348 - Service Abstraction Patterns

The core problem is the tight coupling and interdependencies of a monolithic architecture, which leads to fragility. Breaking the monolith into a set of smaller, independently deployable services (a microservice architecture) directly addresses this issue. Each microservice can manage a specific business capability (e.g., billing, ERP connection). This approach promotes loose coupling, improves fault isolation (failure in one service doesn't bring down the entire system), and enhances performance by allowing independent scaling of services. This modular design is the standard architectural solution for decoupling complex, interdependent systems.

A. Using the Bulk API is a tactic for large data volume, not a strategy to fix a flawed, tightly-coupled monolithic architecture.

B. Moving the monolith to the cloud ("lift and shift") does not solve the underlying architectural problem of tight coupling; it only changes its location.

1. Salesforce Architects, "Architect's Guide to Integration Patterns and Practices", Page 6. The guide warns against point-to-point integrations creating a "spaghetti" architecture and advocates for middleware to decouple systems, a principle embodied by a microservices architecture.

2. Martin Fowler, "Microservices". (martinfowler.com/articles/microservices.html). This seminal article, widely referenced in software architecture, defines microservices as an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms. This directly contrasts with the monolithic approach described in the problem.

The key requirements are real-time access ("view and update real-time") and that the data must not be stored in Salesforce ("only persist in the external system"). This scenario perfectly describes the Data Virtualization integration pattern. This pattern allows a system (Salesforce) to query and display data from a remote system on-demand without copying or synchronizing it. The data remains in the external system of record, ensuring it is always current, while users can interact with it seamlessly within the Salesforce UI. Salesforce Connect is the primary feature that implements this pattern.

A. Data Synchronization involves copying and storing data in Salesforce, which directly violates the requirement that data only persist in the external system.

C. Process Orchestration is a pattern for coordinating multi-step, multi-system processes. While it might use data virtualization, it is not the specific pattern that describes the data access method required here.

1. Salesforce Architects, Integration Patterns and Practices, "Data Virtualization" pattern. The guide defines this pattern as providing "real-time access to the latest data from an external system... without having to persist that data in Salesforce." This directly matches the question's requirements.

2. Salesforce Help, Salesforce Connect. The documentation states, "Salesforce Connect lets your users view, search, and modify data that’s stored outside your Salesforce org... Instead of copying the data into your org, you can use external objects to access the data in real time via web service callouts."

3. Salesforce Trailhead, Salesforce Connect, "Get Started with Salesforce Connect" module. This module explains that Salesforce Connect is used when you have a large amount of data you don’t want to copy into your Salesforce org and you need real-time access.

A third-party SSO solution is the most appropriate approach for this complex multi-authentication scenario. It can federate multiple identity providers (local Active Directories, social logins, partner systems) while providing centralized management and security. This solution addresses all stated requirements: supporting multiple Active Directory instances for different countries, enabling social login for customers, integrating with a future partner authentication system, and maintaining secure access to the ERP system.

A. Salesforce native authentication cannot federate with multiple Active Directory instances or integrate with external ERP credentials as required.

B. Building custom authentication for each country would be complex, costly, and difficult to maintain while lacking standard security features.

3. References:

1. Salesforce Identity and Access Management Guide, "Single Sign-On Implementation Guide," Section 3.2 - Federation Standards, pp. 15-18

2. Salesforce Architecture Design Guide, "Multi-Org Strategy and Identity Management," Chapter 4, pp. 42-45

3. Trailhead: "Identity and Access Management Architecture" module, Unit 3: Federation Patterns

4. Salesforce Platform Integration Patterns, "Authentication Patterns for Enterprise Integration," Section 2.4, pp. 28-31

5. Salesforce Security Implementation Guide, "Enterprise SSO Configuration," Chapter 5.3, pp. 67-70

1. Salesforce Identity Implementation Guide, “Third-Party Identity Provider and SSO Architecture,” pp. 20-23 (Winter ’24 release).

2. Salesforce External Identity & Customer Login Options, “Federation with Social and Enterprise IdPs,” p. 5 (Aug 2023 documentation).

Named Credentials are Salesforce's recommended approach for storing authentication details securely. They encrypt credentials at rest and in transit, while abstracting authentication complexity from code. Protected Custom Metadata Types provide an additional secure storage option with encryption capabilities and controlled access through permissions. Together, they offer the most comprehensive security for secrets, preventing both deliberate and inadvertent exposure while maintaining developer-friendly implementation.

Option B: Encrypted Custom Fields lack the authentication abstraction that Named Credentials provide, requiring manual encryption/decryption in code which increases exposure risk.

Option C: Protected Custom Settings are less secure than Protected Custom Metadata Types as they can be accessed via API and have weaker permission controls.

1. Salesforce Security Guide - "Named Credentials Implementation" - Section 4.2, Pages 89-92

2. Salesforce Developer Documentation - "Custom Metadata Types Security" - Protected Custom Metadata Types section

3. Salesforce Platform Encryption Guide - "Encryption Best Practices" - Chapter 7, Sections 7.3-7.4

4. Salesforce Integration Patterns and Practices - "Secure External Callouts" - Pages 156-159

5. Trailhead: Secure Your Apps with Named Credentials - Module Overview and Implementation sections