Certified Integration Architect — Free Practice Questions
10 free sample questions from a bank of 76, with the correct answers and explanations. No signup required — start practising right now.
1A company is designing a Lightning Web Component (LWC) to display transactions aggregated from different sources. Their current system landscape is as follows:
1. Transactions are created at any time through their various on-premise and cloud-based systems.
2. All necessary transactions are replicated to a custom Transaction object in Salesforce. It is updated periodically so it only has a subset of the necessary transactions between updates.
3. Middleware supports publish-subscribe interactions and provides RESTful Enterprise APIs that can retrieve transactions from on-premise and cloud-based systems.
The company wants to address a usability concern regarding incomplete data displayed on the LWC component.
What should the integration architect specify so the LWC will be able to display all the required transactions?
Publish a Platform Event, have the middleware subscribe and update the custom object on receipt of Platform Event.
Call the Enterprise APIs directly from the LWC's JavaScript code and redisplay the LWC on receipt of the API response.
Use the Continuation class to call the Enterprise APIs and then process the response in a callback method.
Let the Lightning Data Service with an @wire adapter display new values when the custom object records change.
Answer: C
The short version
C — Use Continuation for live LWC aggregation. The custom Transaction object holds only a periodically replicated subset, so it cannot satisfy the complete-data requirement. Continuation lets Apex fetch live transactions from middleware Enterprise APIs asynchronously and redisplay on callback.
Key concepts in this question
Replicated subset vs live data: the custom object is stale between updates and misses transactions created at any time.
Continuation async callout: Apex Continuation class performs a long-running callout with a callback method without hitting synchronous limits.
Middleware Enterprise APIs: RESTful APIs that retrieve transactions from on-premise and cloud systems with publish-subscribe support.
Why C is correct
The LWC must show all required transactions, not just the periodically replicated subset in the custom Transaction object. The middleware exposes RESTful Enterprise APIs over the on-premise and cloud systems, and the Continuation class enables a long-running asynchronous callout from Apex invoked by the LWC with a callback method. This lets the component fetch live data from all sources and redisplay on response without hitting synchronous callout limits.
Why the others are wrong
A. Publishing a Platform Event for middleware to update the custom object still leaves a replicated subset with latency and does not give live complete data.
B. Calling Enterprise APIs directly from LWC JavaScript exposes credentials and endpoints, violates secure callout patterns and CSP, and must not be done from the JS controller.
D. Lightning Data Service with @wire only reflects the custom object records, which are known to be incomplete between updates.
Certified-Integration-Architect exam tip
Live LWC aggregation equals Continuation, stale replica plus direct JS callout is the trap.
2A new Salesforce program has the following high-level abstract requirement: Business processes executed on Salesforce require data updates between their internal systems and Salesforce.
Which three relevant details should a Salesforce Integration Architect seek to specifically solve for integration architecture needs of the program? (Choose three.)
Integration Style - Process-based, Data-based, and Virtual integration.
Timing aspects, real-time/near real-time (synchronous or asynchronous), batch and update frequency.
Source and Target system, Directionality, and data volume & transformation complexity, along with any middleware that can be leveraged.
Integration skills, SME availability, and Program Governance details.
Core functional and non-functional requirements for User Experience design, Encryption needs, Community, and license choices.
Answer: A, B, C
The short version
ABC — Scope style, timing, and endpoints first. Business processes need data updates between internal systems and Salesforce, so architecture inputs decide pattern and platform. Skills, governance, UX, encryption-at-large, Community, and licenses do not determine integration mechanics.
Key concepts in this question
Integration style: process-based, data-based, and virtual integration determine the pattern family.
Timing and volume: sync versus async, real-time versus near-real-time versus batch, frequency, directionality, volume, and transformation complexity.
Source, target, and middleware: systems involved, direction, and usable middleware constrain interface and platform choices.
Why ABC is correct
An integration architect must first solve for integration architecture: integration style including process, data, and virtual, plus timing such as sync or async, real-time versus batch, and frequency. Source and target system, directionality, data volume and transformation complexity, along with any middleware that can be leveraged, directly determine pattern, interface, and platform choices for data updates.
Why the others are wrong
D. Integration skills, SME availability, and program governance are program management concerns, not integration solution design inputs.
E. UX design, broad encryption needs, Community, and license choices are functional and commercial concerns, not data-update integration mechanics.
Certified-Integration-Architect exam tip
Remember style, timing, direction, volume, transform, and middleware, staffing and UX come later.
3An integration architect has received a request to prevent employees that leave the company from accessing data in Salesforce after they are deactivated in the company’s HR system.
What should the integration architect determine before recommending a solution?
Data access prevention requirements, then identify frequency
Inbound integration requirements, then identify frequency
Data access prevention requirements, integration requirements, and system constraints
Answer: C
The short version
C — Pin down prevention requirements, integration mechanics, and constraints first. Deprovisioning is identity-lifecycle integration where timing, live sessions, and platform limits all shape the design.
Key concepts in this question
Inbound provisioning: HR is the identity source pushing lifecycle changes into Salesforce.
Deactivation vs revocation: flagging a user inactive does not by itself kill live sessions or cached tokens.
Frequency and constraints: sync cadence, API limits, and IdP timing decide batch vs real-time vs SCIM.
Why C is correct
Preventing access after HR deactivation spans what prevent means (record deactivation plus session and token revocation), how HR signals it (SCIM, REST, or middleware), and what the platform allows (API limits, license and IdP timing). Only the comprehensive option covers all three design drivers.
Why the others are wrong
A. Covers prevention plus frequency but skips integration mechanics and system constraints.
B. Covers inbound mechanics plus frequency but skips what access prevention actually requires, including live sessions and tokens.
Certified-Integration-Architect exam tip
For leaver scenarios always ask: does immediate include killing sessions and tokens, and can the IdP deliver that fast?
4A company’s cloud-based single page application consolidates data local to the application with data from on-premise and third-party systems. The diagram below typifies the application’s combined use of synchronous and asynchronous calls. The company wants to use the average response time of its application’s user interface as a basis for certain alerts. For this purpose, the following occurs:
1. Log every call start and finish date and time to a central analytics data store.
2. Compute response time uniformly as the difference between the start and finish date and time (A to H in the diagram).
Which computation represents the end-to-end response time from the user’s perspective?
Sum of A to H
Sum of A to F
Sum A and H
Answer: C
The short version
C — End-to-end user time is Sum A and H. Parallel async legs overlap in wall-clock time, so adding every leg double-counts concurrency. The outer request plus final render span captures true user-perceived latency.
Key concepts in this question
End-to-end vs component sum: user latency is wall-clock from first start to last finish, not additive work.
Synchronous vs asynchronous calls: sync legs block while async legs overlap and complete out of order.
Central analytics logging: every call start and finish is logged, then response math derives alert baselines.
A-to-H diagram semantics: outer segments bound the interaction while inner segments run concurrently.
Alert baseline risk: summing parallel work inflates averages and triggers false performance alerts.
Why C is correct
The single-page app mixes sync and async calls to local plus on-premise and third-party data, so several inner calls execute concurrently within one user interaction. Uniform difference math on every logged leg is useful for diagnostics, but user-perceived response is the elapsed time from the initial UI request to the final UI render. Settled key C represents that wall-clock span as Sum A and H, the outer envelope, rather than the inflated total of overlapping work.
Why the others are wrong
A. Sum of A to H adds concurrent async legs together, overstating wall-clock time the user actually waits.
B. Sum of A to F drops the final render leg, understating the complete user-visible interaction.
Certified-Integration-Architect exam tip
User time equals outer envelope, never sum parallel async legs for the baseline.
5Northern Trail Outfitters has a registration system that is used for workshops offered at its conferences. Attendees use Salesforce Community to register for workshops, but the scheduling system manages workshop availability based on room capacity. It is expected that there will be a big surge of requests for workshop reservations when the conference schedule goes live.
Which integration pattern should be used to manage the influx in registrations?
Batch Data Synchronization
Remote Process Invocation Request and Reply
Remote Process Invocation Fire and Forget
Answer: A
The short version
Banked answer A is retained: the question as worded asks which pattern manages a surge of registrations against room-capacity availability.
Key concepts in this question
Batch Data Synchronization pattern
Remote Process Invocation Request and Reply
Remote Process Invocation Fire and Forget
Surge buffering vs immediate availability confirmation
Why A is correct
A (Batch Data Synchronization) is the banked key for absorbing a go-live surge by decoupling Community registration writes from the scheduling system and reconciling availability in batches. It is held here because there is no cited Salesforce doc proving Fire and Forget handles capacity-checked reservations better, and Request and Reply would couple the UI directly to the constrained scheduler during a surge.
Why the others are wrong
A (Batch Data Synchronization): Retained. Buffers surge and syncs on a schedule; tradeoff is delayed availability feedback.
B (Remote Process Invocation Request and Reply): Wrong for surge management because synchronous reply couples throughput to the slowest scheduler leg and risks timeouts under spike load.
C (Remote Process Invocation Fire and Forget): Plausible for surge absorption with queuing, and tied 50/50 in votes, but it provides no availability reply, which the vendor prose notes is needed to confirm room capacity. Without cited proof it cannot replace banked A.
Certified-Integration-Architect exam tip
Map surge plus consistency needs to pattern: surge favors async or batch, strict immediate confirmation favors Request and Reply. Hold the bank unless docs prove otherwise.
6An enterprise architect has requested the Salesforce integration architect to review the following (see diagram and description) and provide recommendations after carefully considering all constraints of the enterprise systems and Salesforce platform limits. • About 3,000 phone sales agents use a Salesforce Lightning UI concurrently to check eligibility of a customer for a qualifying offer.
• There are multiple eligibility systems that provide this service and are hosted externally. However, their current response times could take up to 90 seconds to process and return (there are discussions to reduce the response times in the future, but no commitments are made).
• These eligibility systems can be accessed through APIs orchestrated via ESB (MuleSoft).
• All requests from Salesforce will have to traverse through the customer's API Gateway layer and the API Gateway imposes a constraint of timing out requests after 9 seconds.
Which recommendation should the integration architect make?
Recommend synchronous Apex callouts from Lightning UI to External Systems via Mule and implement polling on an API Gateway timeout.
Create a platform event in Salesforce via Remote Call-In and use the empAPI in the Lightning UI to serve 3,000 concurrent users when responses are received by Mule.
Implement a "Check Update" button that passes a requestID received from ESB (user action needed).
Answer: C
The short version
C — Use requestID plus Check Update for 90-second eligibility. Nine-second gateway timeout plus 3k concurrent users rules out sync Apex. A user-driven poll on ESB requestID decouples the long backend from Salesforce limits.
Key concepts in this question
Gateway nine-second limit: customer API Gateway times out long calls, so sync patterns fail by design.
Ninety-second backend: external eligibility services far exceed callout and gateway budgets.
Concurrency scale: 3k Lightning users need a pattern that does not hold transactions open.
ESB orchestration: MuleSoft fronts multiple systems and can return a correlation requestID immediately.
User-action polling: Check Update button re-queries by requestID when the agent is ready.
Why C is correct
Synchronous Apex callouts from Lightning would hold gateway and Apex transactions open for up to 90 seconds and collapse under gateway timeout at 9 seconds plus concurrent limits for 3k agents. Returning an ESB requestID immediately and letting the agent click Check Update to fetch the completed eligibility result moves the wait outside the transaction. Settled key C therefore respects gateway, platform, and scale constraints together while keeping agent UX explicit.
Why the others are wrong
A. Sync Apex with gateway-timeout polling still holds callouts open past limits and cannot survive 90-second backends.
B. Platform-event push via empAPI adds streaming scale complexity for 3k users and still needs correlation without solving the gateway wait.
Certified-Integration-Architect exam tip
Long backend plus short gateway equals async requestID plus user poll, never sync.
7A customer imports data from an external system into Salesforce using Bulk API. These jobs have batch sizes of 2000 and are run in parallel mode. The batches fail frequently with the error “Max CPU time exceeded”. A smaller batch size will fix this error.
What should be considered when using a smaller batch size?
Smaller batch size may exceed the concurrent API request limits.
Smaller batch size can trigger “Too many concurrent batches” error.
Smaller batch size may increase time required to execute bulk jobs.
Answer: C
The short version
Banked answer C is retained for this single-select Bulk API question: smaller batches reduce CPU timeouts but increase total job elapsed time.
Key concepts in this question
Bulk API parallel mode with 2000-record batches
Max CPU time exceeded on large batches
Batch-size vs batch-count tradeoff
Job elapsed time and API consumption
Why C is correct
C (Smaller batch size may increase time required to execute bulk jobs) is universally true: more batches means more queueing, more transactions, and more round trips, so total wall-clock rises even as per-batch CPU falls. It is the only option that is always a consideration regardless of limit headroom, and no cited doc proves B is the intended single answer.
Why the others are wrong
A (May exceed concurrent API request limits): Plausible because more batches means more API calls, but it is conditional on org limits and not the primary guaranteed tradeoff in the single-select form.
B (Can trigger Too many concurrent batches error): Community-preferred and plausible under parallel mode, but it describes a limit that may or may not be hit; without doc proof it cannot replace the always-true time tradeoff as the single key.
C (May increase time required): Retained as the guaranteed consideration.
Certified-Integration-Architect exam tip
For single-select Bulk batch-size questions, the time-increase tradeoff is the safe textbook consideration; limit errors belong to the choose-two variant.
8Which three considerations should an integration architect consider when recommending Platform Event as an integration solution? (Choose three.)
Event messages using SOQL are unable to be queried.
A Lightning record page for platform events is unable to be created.
Subscribe to an AssetTokenEvent stream to monitor OAuth 2.0 authentication activity.
When an event definition is deleted, it's permanently removed and can't be restored.
Event Monitoring is used to track user activity, such as logins and running reports.
Answer: A, B, D
The short version
ABD — Platform Events are non-queryable, non-UI, and permanently deletable. Event messages cannot be queried with SOQL and no Lightning record page exists for them. Deleting a definition removes it forever, which constrains design and lifecycle.
Key concepts in this question
Non-queryable event messages: Platform Event records cannot be queried with SOQL like normal records.
No Lightning record page: no record page can be created for platform events for UI viewing.
Permanent deletion: deleting an event definition removes it permanently with no restore.
Why ABD is correct
Platform Events have specific limiting considerations: event messages cannot be queried with SOQL like records, and no Lightning record page can be created for platform events. When an event definition is deleted, it is permanently removed and cannot be restored. These constraints shape monitoring, design, and lifecycle decisions when recommending Platform Events.
Why the others are wrong
C. Subscribing to an AssetTokenEvent stream to monitor OAuth 2.0 authentication activity is a standard platform event use case, not a limiting consideration against using Platform Events.
E. Event Monitoring for logins and running reports describes a different feature called Event Monitoring, not a Platform Event consideration.
Certified-Integration-Architect exam tip
Platform Events equal no SOQL, no page, no undelete, AssetToken and Monitoring are distractors.
9A subscription-based media company’s system landscape forces many subscribers to maintain multiple accounts and to login more than once. An Identity and Access Management (IAM) system, which supports SAML and OpenId, was recently implemented to improve the subscriber experience through self-registration and single sign-on (SSO).
The IAM system must integrate with Salesforce to give new self-service customers instant access to Salesforce Community Cloud.
Which requirement should the Salesforce Community Cloud support for self-registration and SSO?
OpenId Connect Authentication Provider and Registration Handler
OpenId Connect Authentication Provider and JIT provisioning
SAML SSO and Registration Handler
Answer: A
The short version
A — OpenID needs Auth Provider plus Registration Handler. Community Cloud must give new self-service customers instant access with SSO and self-registration via an IAM supporting SAML and OpenID. JIT provisioning is SAML-only and cannot serve the OpenID path.
Key concepts in this question
OpenID Connect Authentication Provider: the Salesforce configuration for OpenID-based SSO from the IAM system.
Registration Handler: Apex logic that creates and links self-registered Community users for OpenID Connect.
JIT provisioning scope: Just-in-Time provisioning via SamlJitHandler applies to SAML, not OpenID Connect.
Why A is correct
The IAM system supports SAML and OpenID, and Community Cloud needs self-registration plus SSO for new self-service customers. OpenID Connect Authentication Provider with a Registration Handler supports both SSO and self-registration logic for the OpenID Connect path. JIT provisioning is SAML-only, so it cannot be used for the OpenID integration required here.
Why the others are wrong
B. OpenID Connect with JIT provisioning is invalid because JIT provisioning applies to SAML, not OpenID Connect which uses a Registration Handler.
C. SAML SSO with Registration Handler mismatches the chosen OpenID Connect path and its self-registration requirement for this IAM integration.
Certified-Integration-Architect exam tip
OpenID pairs with Registration Handler, SAML pairs with JIT, never cross them.
10The director of customer service at Northern Trail Outfitters (NTO) wants to capture and trend specific business events that occur in Salesforce in real time. The metrics will be accessed in an ad-hoc manner using an external analytics system. The events are as follows:
1. A customer initiates a product exchange via a Case.
2. A customer service rep clicks on the "Authorize Exchange Product" menu item in the Case.
3. A customer initiates a subscription cancellation via a Case.
4. A customer service rep clicks on the "Initiate Refund" menu item in the Case.
Which solution should meet these business requirements?
Case Trigger after Insert, after update to publish the platform event.
Case Workflow Rule that sends an Outbound Message.
Case after insert Trigger that executes a callout.
Answer: A
The short version
Banked answer A is retained: Case triggers publishing platform events give a real-time, subscribable business-event stream for ad-hoc external analytics.
Key concepts in this question
Business events vs data-change events
Platform events for real-time trending
Outbound Messaging workflow limitations
Trigger callouts and callout-from-trigger restrictions
Why A is correct
A (Case Trigger after Insert, after update to publish platform event) creates a durable event for exchange and cancellation initiations that an external analytics system can subscribe to in real time and replay ad hoc. It fits capture-and-trend better than point-to-point SOAP messages and avoids callout limits in triggers.
Why the others are wrong
A (Trigger publishing platform event): Retained. Covers Case-created events asynchronously with replay for analytics.
B (Workflow Rule Outbound Message): Community-preferred but point-to-point SOAP to a single endpoint, no replay or ad-hoc subscribe semantics, and workflow lifecycle is retired in favor of Flow; not proven as the trending solution.
C (After insert Trigger executing callout): Wrong pattern because callouts cannot run directly in trigger context without async decoupling, add governor risk, and provide no event bus for trending.
Certified-Integration-Architect exam tip
Trending plus ad-hoc subscribe language points to platform events or CDC, not single-endpoint Outbound Messaging or inline callouts.