Question bank
Salesforce Certified Integration Architecture Designer
42 Salesforce Certified Integration Architecture Designer questions with the correct answer and a written explanation, organised across 5 exam domains.
- 42 questions
- 5 domains
- Foundation level
certilumQuestion index
Jump straight to any question. Answers and explanations are inline.
Build Solution
10 questions in this domain
- Question 1Single Choice
According to integration architecture best practices, which execution pattern should be used to avoid the 10-second synchronous timeout limit?
- AAsynchronous patternsCorrect answer
- BSynchronous callouts
- CREST API polling
- DManual Apex triggers
Why this is the answer
Asynchronous patterns such as @future, Queueable, or Batch Apex are preferred for long-running processes to avoid the 10-second synchronous timeout limit.
- Question 2Multiple Select
Which Apex mechanisms can be used to perform asynchronous callouts in a Salesforce integration? Select all that apply.
- A@futureCorrect answer
- BQueueableCorrect answer
- CBatch ApexCorrect answer
- DSynchronous Apex
Why this is the answer
@future, Queueable, and Batch Apex are asynchronous mechanisms. Synchronous Apex executes in the immediate context and can hit timeout limits.
- Question 3Interactive
The Apex trigger in the code block tries to perform a callout. What integration trap is being demonstrated?
- ACallout in a trigger without asynchronous wrapperCorrect answer
- BHeap size explosion
- CNamed Credential missing
- DUsing Platform Events for validation
Why this is the answer
A callout directly inside a trigger execution context is forbidden; it must be wrapped in @future, Queueable, or Batch Apex.
- Question 4Single Choice
Which limit error is associated with parsing a massive JSON response in a single synchronous transaction?
- AApex heap size exceededCorrect answer
- BSocketTimeoutException
- CSystem.CalloutException
- DQueryException
Why this is the answer
Parsing large JSON payloads in one synchronous transaction can cause LimitException: Apex heap size exceeded.
- Question 5Multiple Select
Which strategies should an architect use to create a resilient HTTP callout process in an integration design?
- AHandling 4xx and 5xx status codesCorrect answer
- BImplementing exponential backoffCorrect answer
- CUsing Platform Events to signal failed integration attemptsCorrect answer
- DIgnoring server errors
Why this is the answer
Resilient callouts handle HTTP error codes, retry with exponential backoff, and can use Platform Events to trigger reprocessing of failures.
- Question 6Interactive
In the Apex code block, what does the named endpoint reference in the HTTP request?
- AA Named Credential abstractionCorrect answer
- BA raw external URL
- CA Platform Event channel
- DA Queueable job name
Why this is the answer
A Named Credential abstracts the endpoint and authentication details, allowing Apex to reference it with the callout: prefix.
- Question 7Single Choice
Which protocol does Change Data Capture use to stream object changes from Salesforce to external subscribers?
- ACometDCorrect answer
- BSOAP
- CREST
- DBulk API
Why this is the answer
CDC uses the CometD protocol for long-polling, enabling Salesforce to act as event producer for external subscribers.
- Question 8Multiple Select
Which statements about Platform Event replay are true according to the integration architecture playbook? Select all that apply.
- AThe replay window is typically 72 hoursCorrect answer
- BReplay ID lets subscribers recover missed eventsCorrect answer
- CReplay supports eventual consistency after network failuresCorrect answer
- DEvents are retained indefinitely
Why this is the answer
Salesforce keeps a replay window of about 72 hours, and Replay IDs let subscribers recover missed events for eventual consistency.
- Question 9Interactive
What event publishing mode is demonstrated by the Apex code block shown in the question?
- ABefore CommitCorrect answer
- BAfter Commit
- CReplay Only
- DChange Data Capture
Why this is the answer
The event is published before the insert commits, which risks sending an event for a transaction that may roll back.
- Question 10Single Choice
What is a primary benefit of event-driven decoupling for a publishing system in an integration architecture?
- AReduced latency in the primary transactionCorrect answer
- BGuaranteed synchronous subscriber response
- CUnlimited event retention
- DDirect call to each subscriber
Why this is the answer
Event-driven decoupling lets the publisher broadcast a state change without waiting, reducing latency and preventing cascading failures.
Design Integration Solutions
12 questions in this domain
- Question 11Single Choice
What is the primary characteristic of a synchronous integration callout?
- ABlocks the UI until the callout completesCorrect answer
- BRuns in the background with @future
- CAlways uses Platform Events
- DCannot connect to external systems
Why this is the answer
Synchronous callouts block the current transaction until they finish. They are limited by the 10-second timeout and should not be used for long-running operations.
- Question 12Multiple Select
Which options are supported asynchronous callout mechanisms in Apex? Select all that apply.
- A@future methodsCorrect answer
- BQueueable ApexCorrect answer
- CBatch ApexCorrect answer
- DSynchronous REST callout
Why this is the answer
Apex provides @future, Queueable, and Batch Apex for asynchronous callouts. Synchronous REST callouts execute in the original request context.
- Question 13Interactive
Review the code block. Which integration trap is illustrated?
- ATrigger Callout ErrorCorrect answer
- BTimeout Oversight
- CHeap Size Explosion
- DAuthentication Failure
Why this is the answer
A callout directly inside a trigger is not allowed. It must be wrapped in an asynchronous mechanism such as @future or Queueable Apex.
- Question 14Single Choice
What is the synchronous callout timeout limit in Salesforce?
- A10 secondsCorrect answer
- B30 seconds
- C60 seconds
- D120 seconds
Why this is the answer
Salesforce enforces a 10-second timeout for synchronous callouts. Longer-running work should use asynchronous Apex patterns.
- Question 15Multiple Select
Which two callout governance practices help avoid Salesforce limit exceptions?
- ASet explicit HTTP timeoutsCorrect answer
- BMonitor heap size for response payloadsCorrect answer
- CIgnore the response body size
- DRaise the callout limit per transaction
Why this is the answer
Setting timeouts and watching heap usage keep integrations within platform constraints. Callout limits cannot be changed by the architect.
- Question 16Interactive
Analyze the code block. Which trap is it most likely to cause?
- AHeap Size ExplosionCorrect answer
- BTrigger Callout Error
- CTimeout Oversight
- DNamed Credential Misconfiguration
Why this is the answer
Deserializing a very large JSON response into memory can quickly exceed the Apex heap limit and throw LimitException.
- Question 17Single Choice
What should an architect use to securely abstract callout authentication?
- ANamed CredentialsCorrect answer
- BCustom Labels
- CStatic Resources
- DRemote Site Settings
Why this is the answer
Named Credentials abstract authentication and help manage OAuth flows securely. They avoid exposing credentials in Apex code.
- Question 18Multiple Select
Which two strategies improve error handling and retry logic for integrations?
- AImplement exponential backoff on retriesCorrect answer
- BUse Platform Events to flag failed attemptsCorrect answer
- CDisable timeouts to avoid errors
- DLog credentials for debugging
Why this is the answer
Exponential backoff prevents retry storms, and Platform Events can signal failures for later processing. Disabling timeouts or logging credentials is unsafe.
- Question 19Interactive
What issue does this code block reflect?
- ATimeout OversightCorrect answer
- BHeap Size Explosion
- CTrigger Callout Error
- DSerialization Failure
Why this is the answer
The code makes a synchronous callout without designing for external system latency. A slow system can cause SocketTimeoutException.
- Question 20Single Choice
How long is the standard replay window for Platform Events?
- A72 hoursCorrect answer
- B24 hours
- C7 days
- D30 days
Why this is the answer
Platform Events provide a replay window of about 72 hours. Replay IDs allow consumers to recover missed events within that window.
- Question 21Multiple Select
Which two statements describe Publish After Commit behavior for Platform Events?
- ASent only after database transaction commitsCorrect answer
- BHelps preserve data integrityCorrect answer
- CSent before transaction rollback
- DNotifies subscribers before validation
Why this is the answer
After Commit publishing ensures events are not emitted for rolled-back transactions. This protects data integrity in the integration design.
- Question 22Interactive
Which key reliability feature is missing from the event consumer in the code block?
- AReplay ID handlingCorrect answer
- BExponential backoff
- CNamed Credentials
- DPublish After Commit
Why this is the answer
Without storing or using Replay IDs, a consumer cannot recover from a disconnect and resume from the last successfully processed event.
Evaluate Business Needs
5 questions in this domain
- Question 23Single Choice
In Salesforce integration architecture, which action represents the trap known as the Trigger Callout Error?
- ACallout in @future method
- BDirect callout in trigger without async wrapperCorrect answer
- CCallout in Queueable Apex
- DCallout in Batch Apex
Why this is the answer
The playbook identifies direct callouts in a trigger with no asynchronous wrapper as the Trigger Callout Error trap. The recommended alternatives are @future, Queueable, and Batch Apex.
- Question 24Multiple Select
According to the playbook, which two benefits does event-driven decoupling provide in system integration architecture?
- AReduces latency in the primary transactionCorrect answer
- BPrevents cascading failures if downstream system unavailableCorrect answer
- CGuarantees immediate synchronous responses
- DRemoves the need for replay identifiers
Why this is the answer
The playbook states event-driven decoupling reduces latency in the primary transaction and prevents cascading failures when a downstream system is temporarily unavailable. It does not guarantee synchronous responses or remove replay requirements.
- Question 25Interactive
Review the provided Apex code snippet. Which Salesforce integration architecture trap does the trigger implementation demonstrate?
- ATrigger Callout ErrorCorrect answer
- BTimeout Oversight
- CHeap Size Explosion
- DPublish/Subscribe Model
Why this is the answer
The code makes a synchronous HTTP callout directly inside a trigger with no asynchronous wrapper. This matches the Trigger Callout Error trap described in the playbook.
- Question 26Single Choice
According to the playbook, what is a key architectural benefit of using middleware as a buffer for system integration?
- AGuarantees synchronous responses to all callers
- BAccepts requests and processes them in the backgroundCorrect answer
- CRemoves the need for authentication in all integrations
- DConverts every payload to XML format
Why this is the answer
Middleware can accept the request, acknowledge receipt, and process it in the background. This prevents timeout errors and protects Salesforce resource availability when integrating with slow legacy systems.
- Question 27Multiple Select
Which two statements about Change Data Capture Replay IDs are correct according to the integration architecture playbook?
- AEvery CDC event is assigned a unique Replay IDCorrect answer
- BReplay IDs allow consumers to recover from connectivity failuresCorrect answer
- CReplay IDs are only available for Platform Events, not CDC
- DReplay IDs expire every 24 hours
Why this is the answer
Each CDC event has a unique Replay ID, allowing consumers to recover from connectivity failures by requesting missed events. They are not Platform Events-only and do not expire in 24 hours.
Identity and Access Management
6 questions in this domain
- Question 28Single Choice
Which Salesforce feature abstracts and manages authentication logic for outbound integration callouts?
- ANamed CredentialsCorrect answer
- BPlatform Events
- CChange Data Capture
- DFlow Orchestration
Why this is the answer
Named Credentials abstract authentication by storing endpoint URLs and credentials, so Apex callouts do not manage OAuth directly.
- Question 29Multiple Select
Which practices help maintain security when making callouts? Select all that apply.
- AUsing Named Credentials to avoid hard-coded secretsCorrect answer
- BEnsuring OAuth flows are handled correctlyCorrect answer
- CPreventing sensitive data leakage through secure loggingCorrect answer
- DStoring credentials in Apex classes for reuse
Why this is the answer
Named Credentials, correct OAuth handling, and secure logging are security best practices; storing credentials in Apex is unsafe.
- Question 30Interactive
The Apex code below represents a known integration anti-pattern. What is the architectural trap?
- AThe Trigger Callout ErrorCorrect answer
- BThe Timeout Oversight
- CThe Heap Size Explosion
- DThe Publish/Subscribe Misuse
Why this is the answer
Performing a callout directly in a trigger without an asynchronous wrapper is the Trigger Callout Error trap.
- Question 31Single Choice
Which statement best describes the synchronous callout timeout limit in Salesforce?
- A10 secondsCorrect answer
- B20 seconds
- C30 seconds
- D5 seconds
Why this is the answer
Synchronous callouts must complete within the 10-second timeout limit or they fail with a timeout exception.
- Question 32Multiple Select
Which platform constraints apply to callouts? Select all that apply.
- AMaximum number of callouts per transactionCorrect answer
- BHeap size limitations for large payloadsCorrect answer
- CStrictly enforced timeout limitsCorrect answer
- DAutomatic callout retries for every error
Why this is the answer
Salesforce enforces callout count limits, heap size limits, and timeout limits, but it does not automatically retry every failed callout.
- Question 33Interactive
The Apex method below calls an external system. What is the most likely runtime failure if that system has high latency?
- ASocketTimeoutException caused by exceeding the 10-second limitCorrect answer
- BLimitException: Apex heap size exceeded
- CCallout not allowed in trigger
- DInvalid OAuth token
Why this is the answer
A synchronous callout to a known high-latency system is likely to exceed the 10-second timeout and throw SocketTimeoutException.
Translate Needs to Integration Requirements
9 questions in this domain
- Question 34Single Choice
What is the primary reason to use asynchronous Apex, such as Queueable or @future, for a long-running callout?
- ATo block the UI until the callout completes
- BTo avoid hitting the 10-second synchronous timeout limitCorrect answer
- CTo automatically increase the heap size for large payloads
- DTo eliminate all platform governor limits
Why this is the answer
Asynchronous Apex patterns are preferred for long-running processes because synchronous callouts are subject to a strict 10-second timeout limit. Moving the callout to an asynchronous context prevents the timeout and keeps the UI responsive.
- Question 35Multiple Select
Which two scenarios clearly require an asynchronous integration pattern instead of a synchronous callout?
- AThe external system response may exceed the 10-second timeoutCorrect answer
- BThe process is long-running and may exhaust synchronous execution limitsCorrect answer
- CThe payload is small and the external API always responds instantly
- DThe callout count remains below the per-transaction limit
Why this is the answer
Asynchronous patterns are required when there is a risk of exceeding the synchronous timeout or when long-running work may exhaust execution limits. Small, fast, low-volume callouts do not necessarily require asynchronous handling.
- Question 36Interactive
Given the Apex trigger in the code block, which architectural trap does it demonstrate?
- AThe Trigger Callout ErrorCorrect answer
- BThe Timeout Oversight
- CThe Heap Size Explosion
- DEvent-Driven Decoupling
Why this is the answer
Performing a callout directly inside a trigger execution context is a well-known trap. Callouts inside triggers require an asynchronous wrapper, such as Queueable or @future, to avoid blocking the trigger and risking platform limits.
- Question 37Single Choice
What is the main benefit of using Named Credentials for integration callouts?
- AThey increase the callout timeout limit
- BThey abstract authentication logic and securely store credentialsCorrect answer
- CThey automatically convert JSON responses into Apex objects
- DThey remove the need for any security protocol
Why this is the answer
Named Credentials centralize and abstract authentication details, including OAuth flows, so developers do not expose or hard-code credentials in Apex. This is a core security best practice for callouts.
- Question 38Multiple Select
Which two factors are critical when processing a very large JSON response synchronously?
- AApex heap size limitsCorrect answer
- BCPU time limits during parsingCorrect answer
- CThe 72-hour replay window
- DThe number of Named Credentials available
Why this is the answer
Heap size and CPU time are key limits when deserializing and processing large JSON payloads. Replay windows apply to event streaming, not to synchronous JSON parsing, and Named Credentials are unrelated to payload size.
- Question 39Interactive
Which platform limit is most likely to be exceeded when executing the code block in a synchronous transaction?
- ASocketTimeoutException
- BLimitException: Apex heap size exceededCorrect answer
- CCalloutException: Unauthorized endpoint
- DQueryException: Too many SOQL queries
Why this is the answer
Deserializing a massive JSON payload in a single synchronous transaction can quickly exhaust Apex heap memory, resulting in a LimitException for heap size. This is the Heap Size Explosion trap.
- Question 40Single Choice
What is a key characteristic of Platform Events in an event-driven architecture?
- AThey are only used for synchronous data validation
- BThe publisher broadcasts a state change without waiting for subscriber responsesCorrect answer
- CThey guarantee immediate delivery before the transaction commits
- DThey replace Custom Objects for all persistent data storage
Why this is the answer
Platform Events support event-driven decoupling by allowing the publisher to emit an event and continue without waiting. This reduces latency in the primary transaction and prevents cascading failures if downstream systems are unavailable.
- Question 41Multiple Select
Which two practices are recommended when defining the payload of a Platform Event?
- AInclude only the essential data points subscribers needCorrect answer
- BMinimize event size while providing enough context for subscribersCorrect answer
- CAlways include every field from the source object
- DAvoid including any identifiers or metadata
Why this is the answer
An event payload should be as small as possible but still contain enough context for subscribers to act without excessive callback queries. Including every field is wasteful, and omitting identifiers can make the event unusable.
- Question 42Interactive
The code block shows a CometD client subscription callback. Why is preserving the replayId important?
- AIt allows the client to replay missed events after a disconnectCorrect answer
- BIt eliminates the need for OAuth authentication
- CIt extends the replay window beyond 72 hours
- DIt guarantees synchronous response delivery
Why this is the answer
The Replay ID is essential for fault tolerance. If a subscriber disconnects, it can reconnect and request events starting from the last successfully processed Replay ID, ensuring eventual consistency.
Frequently asked questions
Everything about the Salesforce Certified Integration Architecture Designer question bank and how to use it.