{"id":24728,"date":"2026-09-29T12:29:20","date_gmt":"2026-09-29T12:29:20","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=24728"},"modified":"2026-09-29T12:29:20","modified_gmt":"2026-09-29T12:29:20","slug":"salesforce-certified-integration-architect-practice-test-questions-and-exam-dumps-part17-q321-340","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/salesforce-certified-integration-architect-practice-test-questions-and-exam-dumps-part17-q321-340\/","title":{"rendered":"Salesforce Certified Integration Architect Practice Test Questions and Exam Dumps Part17 Q321-340"},"content":{"rendered":"

View Full <\/b>Salesforce Certified Integration Architect Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Q321. Which design best limits the effect of one partner sending unusually high API traffic<\/b><\/p>\n

    \n
  1. <\/b> Shared credentials<\/span><\/li>\n
  2. <\/b> Client specific throttling<\/span><\/li>\n
  3. <\/b> Unlimited concurrency<\/span><\/li>\n
  4. <\/b> Disabled monitoring<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2. Client specific throttling<\/b><\/p>\n

    Explanation<\/b><\/p>\n

    Client specific throttling limits how quickly each partner can submit requests to an integration service. Shared credentials make activity harder to identify. Unlimited concurrency can allow one partner to consume excessive resources. Disabled monitoring reduces operational visibility. Client specific throttling is therefore the correct answer because different consumers may generate very different traffic volumes. Architects can define limits according to expected usage and business priority while protecting Salesforce and middleware from sudden request bursts. Monitoring rejected or delayed requests also helps determine whether legitimate partner demand requires a planned capacity increase.<\/span><\/p>\n

    Q322. Which pattern is best when failed transactions must be stored separately for later investigation<\/b><\/p>\n

      \n
    1. <\/b> Immediate deletion<\/span><\/li>\n
    2. <\/b> Endless retry<\/span><\/li>\n
    3. <\/b> Browser storage<\/span><\/li>\n
    4. <\/b> Dead letter queue<\/span><\/li>\n<\/ol>\n

      Correct Answer: 4. Dead letter queue<\/b><\/p>\n

      Explanation<\/b><\/p>\n

      A dead letter queue stores messages that cannot be processed successfully after normal retry handling is exhausted. Immediate deletion risks losing important business transactions. Endless retry can repeatedly consume resources when the underlying problem is permanent. Browser storage is not an appropriate enterprise recovery mechanism. Dead letter queue is therefore the correct answer because persistent failures need to remain visible and recoverable. Architects should include the original transaction identifier failure reason and replay procedure so support teams can correct the issue and resubmit the message safely.<\/span><\/p>\n

      Q323. Which approach best supports secure communication between Salesforce and middleware over an untrusted network<\/b><\/p>\n

        \n
      1. <\/b> TLS encryption<\/span><\/li>\n
      2. <\/b> Plain text transport<\/span><\/li>\n
      3. <\/b> Anonymous access<\/span><\/li>\n
      4. <\/b> Shared browser cookies<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1. TLS encryption<\/b><\/p>\n

        Explanation<\/b><\/p>\n

        TLS encryption protects information transmitted between Salesforce and middleware from unauthorized viewing while also supporting server identity verification through certificates. Plain text transport exposes business data during transmission. Anonymous access removes identity assurance. Shared browser cookies are inappropriate for server based integrations. TLS encryption is therefore the correct answer because integration payloads may contain customer information transaction data or credentials that require confidentiality. Architects should use supported secure protocol versions validate certificates and manage certificate renewal so encrypted communication remains trustworthy throughout the integration lifecycle.<\/span><\/p>\n

        Q324. Which design best supports several related API operations that must be coordinated as one logical request<\/b><\/p>\n

          \n
        1. <\/b> Manual data entry<\/span><\/li>\n
        2. <\/b> Independent browser calls<\/span><\/li>\n
        3. <\/b> Composite request<\/span><\/li>\n
        4. <\/b> Report export<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3. Composite request<\/b><\/p>\n

          Explanation<\/b><\/p>\n

          A composite request groups several related API operations so they can be coordinated through one logical interaction. Manual data entry and browser calls do not provide reliable system integration. Report export is intended for analytics rather than transactional coordination. Composite request is therefore the correct answer because related Salesforce operations can sometimes be completed with fewer network round trips and with dependencies between subrequests. Architects should understand the transaction behavior limits and error semantics of the selected Salesforce composite capability before relying on it for business critical processing.<\/span><\/p>\n

          Q325. Which strategy best ensures an integration can recover after middleware restarts unexpectedly<\/b><\/p>\n

            \n
          1. <\/b> Keep state only in memory<\/span><\/li>\n
          2. <\/b> Disable retries<\/span><\/li>\n
          3. <\/b> Delete queued work<\/span><\/li>\n
          4. <\/b> Persist processing state<\/span><\/li>\n<\/ol>\n

            Correct Answer: 4. Persist processing state<\/b><\/p>\n

            Explanation<\/b><\/p>\n

            Persisting processing state allows an integration to recover checkpoints pending work and transaction status after middleware restarts. Keeping state only in memory causes progress information to disappear during failure. Disabling retries removes an important recovery mechanism. Deleting queued work risks data loss. Persist processing state is therefore the correct answer because reliable integrations must survive application restarts without losing accepted transactions or processing everything again. Architects should store enough durable state to resume safely and combine this design with idempotency and reconciliation.<\/span><\/p>\n

            Q326. Which practice best identifies whether an external API contract changed unexpectedly<\/b><\/p>\n

              \n
            1. <\/b> Remove schema tests<\/span><\/li>\n
            2. <\/b> Automated contract testing<\/span><\/li>\n
            3. <\/b> Ignore response structure<\/span><\/li>\n
            4. <\/b> Disable version checks<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. Automated contract testing<\/b><\/p>\n

              Explanation<\/b><\/p>\n

              Automated contract testing verifies that an external API continues to provide the expected fields data types and behavior. Removing schema tests or ignoring response structure makes unexpected changes harder to detect. Disabling version checks further reduces compatibility protection. Automated contract testing is therefore the correct answer because integrations can fail when providers alter interfaces even if endpoints remain available. Architects should run contract tests before deployments and periodically against important dependencies so breaking changes are detected before they affect production transactions.<\/span><\/p>\n

              Q327. Which integration concept identifies one authoritative source for a shared reference value<\/b><\/p>\n

                \n
              1. <\/b> Authoritative source designation<\/span><\/li>\n
              2. <\/b> Random source selection<\/span><\/li>\n
              3. <\/b> Shared editing without rules<\/span><\/li>\n
              4. <\/b> Last response always wins<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. Authoritative source designation<\/b><\/p>\n

                Explanation<\/b><\/p>\n

                Authoritative source designation establishes which application owns and supplies the trusted value for a shared piece of information. Random selection and unrestricted shared editing create inconsistent data. Last response wins ignores business ownership and can overwrite correct values. Authoritative source designation is therefore the correct answer because integrations need clear responsibility for reference data such as product classifications customer status or pricing attributes. Architects should document ownership and ensure consuming systems receive updates without independently redefining the same business value.<\/span><\/p>\n

                Q328. Which monitoring method best tracks one transaction through several distributed components<\/b><\/p>\n

                  \n
                1. <\/b> Report scheduling<\/span><\/li>\n
                2. <\/b> User profile review<\/span><\/li>\n
                3. <\/b> Correlated tracing<\/span><\/li>\n
                4. <\/b> Dashboard formatting<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. Correlated tracing<\/b><\/p>\n

                  Explanation<\/b><\/p>\n

                  Correlated tracing uses a shared identifier and related timing information to follow one transaction through Salesforce middleware and external systems. Report scheduling user profile reviews and dashboard formatting do not provide distributed transaction visibility. Correlated tracing is therefore the correct answer because integration failures or latency may occur in any participating component. Architects should propagate a correlation value across requests messages and logs so support teams can reconstruct the complete transaction path and identify where delays or failures occurred.<\/span><\/p>\n

                  Q329. Which design best handles an external system that temporarily cannot accept new work<\/b><\/p>\n

                    \n
                  1. <\/b> Backpressure<\/span><\/li>\n
                  2. <\/b> Increase retries immediately<\/span><\/li>\n
                  3. <\/b> Ignore capacity signals<\/span><\/li>\n
                  4. <\/b> Open more browser sessions<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1. Backpressure<\/b><\/p>\n

                    Explanation<\/b><\/p>\n

                    Backpressure slows rejects or defers incoming work when a downstream system cannot safely accept additional processing. Immediate repeated retries can worsen overload. Ignoring capacity signals may cause cascading failures. Browser sessions are unrelated to backend load management. Backpressure is therefore the correct answer because distributed systems need a controlled response when consumers become saturated. Architects can combine backpressure with queues throttling and monitoring so work is delayed rather than lost and downstream services receive traffic at a sustainable rate.<\/span><\/p>\n

                    Q330. Which pattern is best when Salesforce must call different providers using one common business interface<\/b><\/p>\n

                      \n
                    1. <\/b> Direct provider logic in every Flow<\/span><\/li>\n
                    2. <\/b> Shared password file<\/span><\/li>\n
                    3. <\/b> Hard coded endpoints<\/span><\/li>\n
                    4. <\/b> Strategy abstraction<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 4. Strategy abstraction<\/b><\/p>\n

                      Explanation<\/b><\/p>\n

                      A strategy abstraction exposes one stable business interface while allowing different provider specific implementations behind it. Direct provider logic in every Flow increases duplication. Shared password files create security risk. Hard coded endpoints create tight coupling. Strategy abstraction is therefore the correct answer because Salesforce can request the same business capability without knowing which provider performs it. Routing or configuration can select the appropriate implementation based on region customer or other criteria while keeping core Salesforce processes simpler.<\/span><\/p>\n

                      Q331. Which Salesforce integration concern should be reviewed before running many parallel Bulk API jobs<\/b><\/p>\n

                        \n
                      1. <\/b> Dashboard theme<\/span><\/li>\n
                      2. <\/b> Concurrency and locking<\/span><\/li>\n
                      3. <\/b> Email template count<\/span><\/li>\n
                      4. <\/b> Report folder names<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. Concurrency and locking<\/b><\/p>\n

                        Explanation<\/b><\/p>\n

                        Concurrency and locking should be evaluated before several high volume jobs update Salesforce simultaneously. Dashboard themes email templates and report folders do not affect transactional contention. Concurrency and locking is therefore the correct answer because parallel processing can improve throughput but may also cause record lock conflicts when jobs affect related data. Architects should understand record relationships and choose suitable concurrency levels. In some cases controlled serial processing may produce more reliable overall performance than maximum parallelism.<\/span><\/p>\n

                        Q332. Which design best supports recovering a consumer after events are delivered more than once<\/b><\/p>\n

                          \n
                        1. <\/b> Remove event identifiers<\/span><\/li>\n
                        2. <\/b> Accept duplicate business effects<\/span><\/li>\n
                        3. <\/b> Idempotent event processing<\/span><\/li>\n
                        4. <\/b> Disable replay<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. Idempotent event processing<\/b><\/p>\n

                          Explanation<\/b><\/p>\n

                          Idempotent event processing ensures that repeated delivery of the same logical event does not create duplicate business outcomes. Removing identifiers makes duplicate detection harder. Accepting duplicate effects can create incorrect data. Disabling replay may cause messages to be lost after outages. Idempotent event processing is therefore the correct answer because distributed messaging systems may redeliver events during retries or recovery. Consumers can store processed identifiers or check resulting business state before applying an event again.<\/span><\/p>\n

                          Q333. Which security mechanism should be used when a partner certificate is no longer trusted<\/b><\/p>\n

                            \n
                          1. <\/b> Increase timeout<\/span><\/li>\n
                          2. <\/b> Keep accepting the certificate<\/span><\/li>\n
                          3. <\/b> Disable authentication<\/span><\/li>\n
                          4. <\/b> Revoke trust for the certificate<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 4. Revoke trust for the certificate<\/b><\/p>\n

                            Explanation<\/b><\/p>\n

                            Revoking trust prevents further authentication or secure communication based on a certificate that should no longer be accepted. Increasing timeout values has no security benefit. Continuing to accept an untrusted certificate creates exposure. Disabling authentication weakens security even further. Revoke trust for the certificate is therefore the correct answer because compromised expired or retired certificates should no longer grant integration access. Architects should maintain certificate ownership renewal and revocation procedures so trust relationships can be changed quickly when required.<\/span><\/p>\n

                            Q334. Which approach best preserves compatibility when a consumer cannot immediately adopt a new API version<\/b><\/p>\n

                              \n
                            1. <\/b> Parallel version support<\/span><\/li>\n
                            2. <\/b> Remove the old version immediately<\/span><\/li>\n
                            3. <\/b> Change field meaning silently<\/span><\/li>\n
                            4. <\/b> Ignore the consumer<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 1. Parallel version support<\/b><\/p>\n

                              Explanation<\/b><\/p>\n

                              Parallel version support keeps the existing interface available while consumers migrate to a newer version. Removing the old version immediately can cause production failures. Changing field meaning silently is unsafe. Ignoring consumer constraints weakens integration governance. Parallel version support is therefore the correct answer because enterprise systems often cannot upgrade simultaneously. Architects should define a migration period communicate retirement dates test both versions and eventually remove the old interface after all required consumers have completed migration.<\/span><\/p>\n

                              Q335. Which metric best measures the number of integration transactions waiting for manual correction<\/b><\/p>\n

                                \n
                              1. <\/b> API version<\/span><\/li>\n
                              2. <\/b> Exception queue size<\/span><\/li>\n
                              3. <\/b> User count<\/span><\/li>\n
                              4. <\/b> Dashboard refresh rate<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2. Exception queue size<\/b><\/p>\n

                                Explanation<\/b><\/p>\n

                                Exception queue size measures how many failed transactions currently require investigation or correction. API version user count and dashboard refresh rate do not indicate unresolved integration errors. Exception queue size is therefore the correct answer because persistent growth can reveal a systemic data quality or application problem. Architects should monitor both the number and age of exceptions and assign clear ownership so failed business transactions do not remain unresolved indefinitely.<\/span><\/p>\n

                                Q336. Which data control best validates that a numeric amount remains unchanged after several transformations<\/b><\/p>\n

                                  \n
                                1. <\/b> Browser testing<\/span><\/li>\n
                                2. <\/b> Dashboard comparison<\/span><\/li>\n
                                3. <\/b> Value reconciliation<\/span><\/li>\n
                                4. <\/b> User permission review<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. Value reconciliation<\/b><\/p>\n

                                  Explanation<\/b><\/p>\n

                                  Value reconciliation compares important business values before and after transformation or transmission to ensure they remain correct. Browser testing dashboard comparison and permission reviews do not verify numerical integrity. Value reconciliation is therefore the correct answer because mappings involving currencies quantities or totals can introduce conversion or rounding errors even when messages remain structurally valid. Architects should define expected tolerances where appropriate and investigate differences before downstream systems rely on incorrect values.<\/span><\/p>\n

                                  Q337. Which pattern is best when one request needs responses from several services before returning a result<\/b><\/p>\n

                                    \n
                                  1. <\/b> Scatter gather<\/span><\/li>\n
                                  2. <\/b> Data replication<\/span><\/li>\n
                                  3. <\/b> Event replay<\/span><\/li>\n
                                  4. <\/b> Report subscription<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1. Scatter gather<\/b><\/p>\n

                                    Explanation<\/b><\/p>\n

                                    Scatter gather sends related requests to several services and then collects their responses into one combined result. Data replication copies information. Event replay processes historical events. Report subscriptions deliver analytics. Scatter gather is therefore the correct answer because an integration may need pricing availability and eligibility results from independent services at the same time. Architects should define timeout behavior partial result handling and whether every service response is mandatory before the final aggregated response can be returned.<\/span><\/p>\n

                                    Q338. Which practice best protects integration logs containing customer identifiers<\/b><\/p>\n

                                      \n
                                    1. <\/b> Make logs public<\/span><\/li>\n
                                    2. <\/b> Log access control<\/span><\/li>\n
                                    3. <\/b> Disable authentication<\/span><\/li>\n
                                    4. <\/b> Store logs indefinitely<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2. Log access control<\/b><\/p>\n

                                      Explanation<\/b><\/p>\n

                                      Log access control restricts operational records to authorized users and services. Making logs public or disabling authentication exposes sensitive information. Keeping logs indefinitely can create unnecessary privacy and storage risk. Log access control is therefore the correct answer because integration logs often contain transaction identifiers customer references and error details. Architects should combine access controls with masking retention policies and secure storage so operational visibility does not create another path for unauthorized data exposure.<\/span><\/p>\n

                                      Q339. Which design best prevents one failed transformation from stopping unrelated messages<\/b><\/p>\n

                                        \n
                                      1. <\/b> Global transaction for all messages<\/span><\/li>\n
                                      2. <\/b> Disable error handling<\/span><\/li>\n
                                      3. <\/b> Message level isolation<\/span><\/li>\n
                                      4. <\/b> Delete the whole queue<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3. Message level isolation<\/b><\/p>\n

                                        Explanation<\/b><\/p>\n

                                        Message level isolation ensures that one malformed or failed transaction can be separated without stopping processing of unrelated valid messages. A global transaction couples all work together. Disabling error handling hides failures. Deleting the entire queue causes data loss. Message level isolation is therefore the correct answer because enterprise integrations should continue processing independent transactions when one message fails. Failed items can be routed to an exception queue while other messages proceed normally.<\/span><\/p>\n

                                        Q340. Which governance practice helps ensure integration documentation remains current after production changes<\/b><\/p>\n

                                          \n
                                        1. <\/b> Remove design records<\/span><\/li>\n
                                        2. <\/b> Use verbal updates only<\/span><\/li>\n
                                        3. <\/b> Ignore small changes<\/span><\/li>\n
                                        4. <\/b> Documentation change control<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4. Documentation change control<\/b><\/p>\n

                                          Explanation<\/b><\/p>\n

                                          Documentation change control requires architecture diagrams interface definitions support procedures and related records to be updated when production integrations change. Removing records or relying only on verbal updates creates outdated knowledge. Ignoring small changes can accumulate into significant discrepancies over time. Documentation change control is therefore the correct answer because support teams and future architects need accurate information about current interfaces dependencies and recovery procedures. Documentation updates should be included as part of the normal release and approval process.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Salesforce Certified Integration Architect Exam Dumps and Practice Test Dumps. Q321. Which design best limits the effect of one partner sending unusually high API traffic Shared credentials Client specific throttling Unlimited concurrency Disabled monitoring Correct Answer: 2. Client specific throttling Explanation Client specific throttling limits how quickly each partner can submit requests to […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/24728"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=24728"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/24728\/revisions"}],"predecessor-version":[{"id":24729,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/24728\/revisions\/24729"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=24728"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=24728"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=24728"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}