Salesforce Architect Practice Test

1. In Salesforce's multi-tenant architecture, what mechanism isolates customer data to prevent unauthorized access?

Row-Level Security (RLS)

Organization-level encryption keys

Database row filtering at the storage layer

Shared database tables with tenant identifiers

2. Which governor limit is most critical when designing a batch process for 1 million records?

DML statements per transaction (150)

Heap size per transaction (6 MB)

Query rows per transaction (50,000)

CPU time per transaction (10 seconds)

3. What is the primary benefit of using Salesforce's Platform Events over Change Data Capture for real-time integrations?

Lower API call consumption

Custom payload control and publisher-subscriber decoupling

Automatic field history tracking

Native support for SOAP protocols

4. In a complex Salesforce org, which architectural pattern best handles asynchronous processing of dependent jobs?

Synchronous batch apex with scheduled actions

Queueable apex with chained execution

Future methods with callback handlers

Scheduled actions with immediate batch jobs

5. What is the recommended approach for handling a large data migration involving 5 million records into Salesforce?

Single bulk API batch job with all records

Multiple smaller batches with error handling and rollback capability

Daily scheduled batch jobs over 30 days

Real-time streaming inserts via REST API

6. Which security model should be implemented for a scenario where different sales regions need access only to their own accounts?

Organization-wide defaults with sharing rules

Role hierarchy alone

Public group membership

Manual sharing records

7. In designing a Salesforce solution for 10,000 concurrent users, what is the primary scaling consideration?

API call limits per org

Governor limits apply uniformly regardless of user count

Database storage and query performance optimization

Licensing costs per user

8. What is the key architectural advantage of using Salesforce MuleSoft over point-to-point integrations?

Centralized integration hub reducing dependencies and improving maintainability

Direct Salesforce database access

Elimination of API rate limits

Built-in machine learning capabilities

9. How should an architect design field-level security for sensitive data like salary information in a custom object?

Field permissions in permission sets and profiles only

Encryption at rest plus field permissions

Sharing rules combined with field visibility

Creating separate objects by role

10. What design pattern minimizes SOQL queries in a large-scale reporting scenario?

Real-time SOQL in reports

Denormalization with aggregate fields and scheduled batch calculations

Multiple reports querying the same object

Storing calculations in external databases

11. In a multi-org architecture supporting different business units, which approach best maintains data consistency?

Shared database across all orgs

Org-to-org synchronization via APIs with conflict resolution logic

Manual data entry in each org

Single org with role-based access

12. What is the primary consideration when architecting a solution that requires real-time data synchronization between Salesforce and an external system?

API rate limits and error handling strategy

Salesforce storage capacity only

User license count

Report refresh intervals

13. When designing a custom metadata-driven solution, what is the key benefit over hard-coded logic?

Faster code execution

Configuration changes without code deployment

Lower API usage

Reduced storage requirements

14. In designing a Salesforce solution with complex business logic, when should you use Flow versus Apex?

Always use Apex for best performance

Use Flow for declarative automation; Apex for complex logic exceeding Flow limits

Always use Flow to avoid code maintenance

Use Apex only for batch processing

15. What architectural pattern should be used to handle a scenario where an external system fails during a critical Salesforce integration?

Immediate transaction rollback

Asynchronous processing with retry logic and error queuing

Synchronous blocking until external system responds

Manual error resolution by users