Adaptive rate limiting smooths traffic by shaping request rates to remain within provider limits, and jittered schedules avoid synchronized spikes across jobs. Longer timeouts do not address server-side throttling and may worsen tail latency. More parallelism intensifies the spike and triggers even more 429s. Disabling retries removes resilience to transient failures and can lose work. Token bucket or leaky bucket algorithms match well with provider quotas and are predictable. Jitter prevents “thundering herd” effects when many clients start simultaneously. Scheduling jobs in staggered windows aligns with provider guidance during updates. Observability on rate-limit headers allows dynamic adjustment. Backoff with full jitter ensures fair use under contention. This combination keeps throughput high while staying compliant.

Option 2 is correct. Kafka is a messaging platform commonly used in Event-Driven Architectures. Option 1 implies synchronous interaction. Option 3 and 4 do not align with Kafka’s use cases.

Option 2 is correct. Heroku Connect replicates data between Salesforce and Heroku Postgres. Option 1 doesn’t store data. Option 3 refers to user interface. Option 4 doesn’t apply here.

Option 1 is correct. MuleSoft acts as middleware facilitating communication. Option 2 handles presentation, not integration. Option 3 manages auth. Option 4 is unrelated.

Option 3 is correct. Webhooks are event-driven mechanisms to notify external systems. Option 1 involves batch. Option 2 is security-related. Option 4 is not push-based like webhooks.

Option 2 is correct. Auth flows and endpoints are integration-relevant. Option 1 is about content. Option 3 and 4 are Salesforce-internal and not integration-specific.

Option 2 is correct. Middleware performing steps and coordinating flows fits orchestration. Other options either don’t match or refer to unrelated functions.

Option 2 is correct. Salesforce Connect virtualizes data access without storing it locally. Option 1 copies data. Option 3 involves files. Option 4 is not relevant.

Option 1 is correct. Since the target system requires XML via SFTP, a batch job that produces the correct format and uses the right protocol is the most suitable. Option 2 and 3 involve JSON and real-time processing, which aren’t compatible with the factory system’s constraints. Option 4 (Salesforce Connect) is used to virtualize external data, not push data in file format.

Option 4 is correct. A nightly push of data in CSV format clearly represents a batch data synchronization pattern. Option 1 is incorrect because it refers to synchronous real-time requests. Option 2 involves UI interactions, which are unrelated. Option 3 is used for near real-time messaging, not batch data export.

Dual-stack support with canary routing allows validating the new TLS configuration with a safe percentage of traffic before full adoption, which materially reduces risk during upgrades. Canarying detects incompatibilities early and provides telemetry for rapid rollback, preserving transaction continuity. A single hard cutover maximizes blast radius and forces a full outage if anything is misconfigured. Adding client retries without topology change does not address protocol incompatibility and simply increases load during failure. Manual host file switches are brittle, error-prone, and not auditable at scale, which undermines resilience. Canary routing combined with automated fallback ensures mean time to recovery is minimized. It also supports progressive migration aligned with governance. Observability hooks during canary phases catch certificate or cipher issues. Dual endpoints let teams perform synthetic tests continuously. This approach creates a repeatable pattern for future protocol updates.

A version-aware mediation layer can detect and adapt to different ERP schema versions, normalizing them to a stable canonical model for clients. This isolates downstream consumers from staggered rollouts and reduces coordination overhead across regions. Direct client mappings are fragile; every client must change simultaneously, magnifying risk. A big-bang refactor ties many teams to one date, and any delay causes outages. Suppressing errors hides problems and can corrupt data by dropping important changes silently. Mediation supports feature flags, A/B testing, and schema evolution with contract tests. It provides a controlled boundary where transformations are observable and reversible. Centralized normalization eases audit and troubleshooting. Consumers remain stable while backends evolve independently. This design supports blue/green or region-by-region adoption seamlessly.

Vault-backed dynamic credentials or JWKS-based key discovery allow automated rotation without service interruption, ensuring tokens validate with current keys and reducing operational toil. Manual runbooks are error-prone and introduce human latency, which can cause downtime. Extending token lifetime increases blast radius for compromise and violates security best practices. Hardcoding multiple secrets is insecure and inflexible, complicating audits and rollbacks. Automated rotation integrates with CI/CD and policy-as-code, enabling predictable change windows. JWKS provides standard discovery for public keys supporting seamless key rollover. Dynamic secrets also support immediate revocation if compromise is suspected. This pattern keeps secrets out of code and configuration repositories. It reduces mean time to recovery in key incidents. Observability around rotation success prevents silent failures.

A circuit breaker with graceful degradation avoids cascading failures during throttling by quickly detecting error rates and backing off, while progressively migrating to the new endpoint reduces risk. Retrying aggressively amplifies throttling and can trigger broader rate limits. Stopping all calls interrupts the business process and creates backlogs and manual work. Waiting to switch until the shutdown date compresses risk into one moment without telemetry. The breaker protects upstream systems and keeps the UX responsive with fallbacks like queuing or delayed labels. Progressive migration enables canary test coverage and performance validation. Degradation paths can display accurate status to users, preserving trust. This approach supports monitoring of both legacy and new endpoints. It provides levers to tune traffic during the transition. Ultimately it balances availability, performance, and change risk.

Dual-writing with a feature flag keeps both representations available during the transition and allows consumers to migrate on their timeline. Read-through detokenization maintains backward compatibility while you validate downstream readiness. Forcing immediate replacement creates coordinated outages across many systems. Freezing writes is operationally unacceptable and risks data loss or business interruption. Emailing PII breaks security controls and auditability and is noncompliant. Feature flags permit controlled rollout per consumer or region. Detokenization services can be monitored and rate-limited to prevent abuse. This approach provides a reversible path if issues are found. Data lineage remains intact with clear mapping between original and tokenized values. It also supports progressive compliance hardening once migration completes.

The correct answer is 2. Real-time API calls for immediate processing align with the Request and Reply pattern. Option 1 is replication-focused. Option 3 involves delay. Option 4 refers to async notification, not real-time processing.

Bulkheads isolate failures by confining resource exhaustion to a single dependency, while prioritized queues ensure critical workloads are served first during constrained capacity. A single shared pool allows one noisy neighbor to starve others and magnifies failure impact. Removing queues eliminates backpressure and can translate transient slowdowns into widespread timeouts. Forcing synchronous paths increases coupling and raises the chance that a single slow hop breaks the entire chain. Bulkheads mirror ship compartments: a leak in one does not sink all. Prioritized queues protect key flows (e.g., payments) during maintenance. This pattern enables controlled degradation rather than total failure. It works well with circuit breakers and rate limiting. Metrics on queue depth and latency guide dynamic throttling. The result is graceful performance under constrained resources.

Using short TTLs with health-checked discovery ensures clients pick up new endpoints quickly, while automating allowlists keeps network controls in sync with vendor IP changes. Hardcoding IPs leads to outages when ranges change and is difficult to maintain across environments. Static hosts entries are similarly brittle and invisible to standard monitoring. Client retries do not help if connections fail due to blocked IPs or stale DNS; they only waste resources. Automated network policy updates reduce manual errors and speed recovery. Health checks validate reachability before traffic shifts. Short TTLs balance responsiveness with DNS load. This design supports blue/green and failover scenarios. It also provides governance artifacts for audit. Together these practices prevent downtime during DNS or IP migrations.

Moving external calls out of triggers and into asynchronous mechanisms like Platform Events or Queueables decouples business transactions from external dependencies and governor changes. Try/catch in triggers does not mitigate callout limits or transaction rollbacks under load. Parallelizing synchronous futures is constrained by platform limits and can still hit governor changes during releases. Formula fields and validation rules cannot perform callouts or orchestrate retries. Asynchronous patterns allow backoff, idempotency, and dead-letter handling during vendor updates. They reduce user-facing latency and avoid partial commits. Subscriber services can be versioned independently. Monitoring and replay capabilities increase operational resilience. This architecture aligns with Salesforce best practices for integration robustness.

Contract tests formalize expected behaviors and, with consumer-driven mocks, ensure the upgraded library still satisfies downstream expectations or is adapted via compatibility shims. Upgrading in production is risky and shifts validation to customers. Removing error handling increases blast radius and degrades user experience during incidents. Disabling timeouts can create resource starvation and cascading failures under load. Compatibility shims translate new error codes to stable ones, shielding clients. Tests run in CI prevent regressions from reaching production. Mocks capture edge cases that real dependencies may not easily reproduce. This approach supports phased rollout with confidence. Observability verifies parity in real traffic. Together they create a robust safety net for library updates.

Option 2 is correct because fallback systems with caching can handle temporary disruptions without losing data or functionality. Option 1 increases failure risk. Option 3 affects user trust. Option 4 is an overreaction and halts business.

Option 1 is correct because HTTPS with TLS provides encryption and secure transmission. Option 2 is insecure. Option 3 exposes secrets. Option 4 is a compliance violation.

Option 1 is correct because Platform Events with durable subscribers guarantee that messages are retained until acknowledged. Option 2 is unreliable. Option 3 pushes complexity to the client. Option 4 results in lost data.

Option 3 is correct because mutual TLS confirms both parties‘ identities, ensuring encrypted and trusted communication. Option 1 is partial. Option 2 misses the client side. Option 4 is irrelevant to authentication.

Option 1 is correct because exponential backoff avoids overwhelming systems and provides time for recovery. Option 2 may cause spikes. Option 3 ignores resolution chances. Option 4 is inefficient.

Option 2 is correct because token-based authentication validates authorized access. Option 1 is reactive. Option 3 is insecure. Option 4 is passive.

Option 2 is correct because combining retries with timeout handling addresses latency and ensures retry after temporary failure. Option 1 causes blocking. Option 3 bypasses security. Option 4 is irresponsible.

Option 2 is correct because TLS encrypts the entire communication channel, including sensitive credentials. Option 1 exposes credentials. Option 3 and 4 violate best practices.

Option 3 is correct because decoupling using mapping layers allows flexibility during schema evolution. Option 1 creates fragility. Option 2 is negligent. Option 4 introduces risk.

Option 3 is correct because before taking any further action, identifying the root cause ensures informed resolution. Option 1 may repeat failures without understanding the issue. Option 2 should follow analysis. Option 4 may spread unnecessary concern before a fix is in place.

API call volume over time reveals usage spikes and helps plan for scaling. Licenses and object count are not traffic indicators. Login history is user-level.

An API gateway with versioning allows the integration to abstract away backend changes and provide controlled exposure of API versions. This prevents direct impact on consumers and ensures compatibility during updates. Direct SOAP callouts make the system fragile due to tight coupling. Ignoring versioning leads to failure when APIs change. Statelessness is beneficial, but without versioning it doesn’t ensure resilience.

Asynchronous processing with retry logic ensures that messages or operations are retried automatically if the target system is down, reducing the need for manual intervention. Manual resumption and pausing are not scalable or reliable in high-availability environments. Availability calendars may not always reflect unexpected downtime. Retry logic ensures resilience and uptime.

Breaking data into smaller batches allows targeted retries and minimizes reprocessing. It improves throughput and isolates issues, preventing a single failure from halting the entire job. Skipping records without retrying can result in data loss. Transactional commits per record may not be efficient. Aborting the whole batch compromises availability.

Durable streaming with replay IDs ensures reliable message delivery even if the subscriber temporarily disconnects. It supports replay of missed events and maintains resilience. Polling and batch jobs are not optimal for real-time and reliable processing. Confirmation patterns add complexity and don’t ensure replay.

Idempotency ensures that retries of the same operation don’t cause duplication or inconsistency. This is vital in ensuring resilience, especially with retry logic, so that failures can be retried safely. It doesn’t directly address latency or response times. It’s unrelated to authentication.

Canary releases or blue-green deployments reduce risk by shifting traffic to updated systems gradually. This ensures fallback is possible and avoids total system disruption. Manual steps and stopping all integrations increase downtime risk. Rollback scripts are reactive rather than preventive.

Persistent message queues store messages until they can be successfully processed. This design ensures that messages aren’t lost during outages. Synchronous APIs and manual intervention don‘t provide guarantees. Disabling endpoints blocks messages entirely.

Versioning APIs allows backward compatibility, so current consumers continue functioning while newer consumers adopt updated versions. In-place updates and undocumented changes break consumers. Tight coupling creates fragility.

Real-time monitoring with alerts allows teams to proactively detect issues and maintain performance SLAs. Static or manual tracking lacks immediacy. Sampling misses full data. This enables faster resolution and more reliable integrations.

Response time, throughput, and error rate tracking provide direct indicators of integration performance. CPU alone doesn’t reflect API behavior. Uptime logs show availability, not performance. Surveys provide subjective data.

APM tools analyze metrics like latency, error rates, and throughput in real time, and trigger alerts when thresholds are breached. Schema Builder and Change Sets are design tools. Custom objects are not suited for monitoring.

Dashboards consolidate key metrics and provide visibility across systems. They don’t eliminate logging, but complement it. Network issues and QA testing still require dedicated approaches. Dashboards help stakeholders track trends and incidents.

Distributed tracing tools are designed to monitor flow across services and calculate exact latency. Server metrics and API limits give partial data. Manual testing isn’t scalable.

Logs and monitoring tools provide historical and real-time insight into the root cause. Guessing and rebuilding are inefficient. Setup menu offers limited diagnostics.

The circuit breaker pattern helps avoid overwhelming a failing system by detecting faults and breaking the connection for a period of time. It prevents endless retries and system strain, which are risks with continuous retry logic. While message queues can help buffer requests, they don’t protect against cascading failures. Synchronous callouts fail immediately and don’t provide resilience.

SLAs define metrics like response time and availability. These are monitored to meet business commitments. They don’t control access or release frequency.

Post-deployment monitoring helps detect regression and issues quickly. Relying on users or increasing volume blindly can lead to failure. Skipping testing is risky.

The correct answer is 4. A batch job ensures data is sent at controlled intervals, avoiding overload. Option 1 risks exceeding the ERP limit. Option 2 helps throttle but requires careful handling of peak volume. Option 3 doesn‘t provide timing control, so it‘s not suitable for strict limits.

The correct answer is 2. A synchronous API call ensures immediate validation during registration. Option 1 is asynchronous and not suitable for real-time needs. Option 3 delays feedback, breaking the real-time requirement. Option 4 offloads logic but still relies on synchrony—option 2 handles it directly and securely.

Option 2 is correct. Storing data locally during offline periods and syncing later ensures reliability. Option 1 requires constant connectivity. Option 3 would fail under poor network conditions. Option 4 only pulls data and doesn‘t address updates from the app.

The correct answer is 2. A nightly batch job fits the timing and format constraints of the legacy system. Option 1 and 3 are real-time, which the mainframe doesn‘t support. Option 4 is invalid due to lack of HTTP support in the mainframe.

The correct answer is 3. An hourly batch respects the external system‘s update window. Option 1 and 4 stream changes in near real-time, violating the hourly limit. Option 2 would flood the system and be incompatible with its constraint.

The correct answer is 2. Generating and emailing a CSV meets the system’s input format and timing. Option 1 and 3 are real-time and format-incompatible. Salesforce Connect only reads external data and wouldn’t generate files.

The correct answer is 2. Middleware can track and throttle calls to stay within limits. Option 1 may exceed limits quickly. Option 3 is for async delivery but doesn’t throttle. Option 4 ignores the constraint and risks lockout.

The correct answer is 3. Named Credentials handle token refresh securely. Option 1 is risky and prone to failure. Option 2 is not secure and not dynamic. Option 4 is insecure and brittle.

Option 2 is correct. Versioning helps determine the latest correct record. Option 1 is non-existent. Option 3 doesn’t prevent conflict. Option 4 increases risk of overwrites without coordination.

Option 2 is correct. Middleware allows data consolidation and performance tuning before Salesforce access. Option 1 would be slow. Option 3 doesn’t aggregate data. Option 4 adds complexity without solving latency issues.

The correct answer is 1. Understanding the integration endpoints and mechanisms is key to mapping the data flow. Options 2, 3, and 4 are important but secondary to establishing technical connectivity.

Option 2 is correct. Batch jobs are a classic batch data sync pattern. Option 1 is synchronous. Option 3 applies to UI cases. Option 4 doesn’t describe batch behavior.