Interview Questions for Salesforce Developer

Start by listing the key steps in the order of execution (e.g., system validation, before triggers, standard validation, after triggers, workflow rules, process builder, flows, escalation rules, roll-up summary fields, commit). Explain where Apex triggers execute. Then, provide a concrete example, such as preventing infinite loops when a trigger updates a field that then re-fires the same trigger, or ensuring data integrity before workflow rules fire. Mention using `Trigger.isBefore`, `Trigger.isAfter`, `Trigger.isInsert`, etc., to control logic.

Start by defining asynchronous Apex and its purpose (bypassing governor limits, long-running operations). Then, present a specific scenario, e.g., 'When integrating with an external system that takes time to respond after a record update' or 'Processing a large volume of data nightly.' For the chosen method (e.g., Batch Apex for large data sets, Queueable for chained jobs, Future for simple callouts), explain its advantages and disadvantages in that context, including governor limits, chaining capabilities, and callout support. Quantify the 'large volume' or 'long-running' aspect.

Explain that Apex runs in 'system mode' by default, meaning it bypasses user permissions. Therefore, you must explicitly enforce security. Detail how to enforce FLS (Field-Level Security) and CRUD (Create, Read, Update, Delete) using `WITH SECURITY_ENFORCED` in SOQL/SOSL, `stripInaccessible()` for DML, or `Schema.SObjectAccessDecision` methods. For sharing, explain using `WITH SHARING` or `WITHOUT SHARING` keywords on Apex classes, and when each is appropriate. Provide examples of when you'd use each, e.g., `WITH SHARING` for user-facing logic, `WITHOUT SHARING` for utility classes or system-level operations.

Start by explaining that LWC is built on web standards (HTML, CSS, modern JavaScript) and is lightweight, faster, and more performant due to its native browser support. Aura is a proprietary framework. Detail key differences: performance, development model (web standards vs. Aura-specific), debugging, and interoperability. State that LWC is generally preferred for new development due to its performance and alignment with web standards. Aura might be used for maintaining legacy code or when specific Aura-only features are required (though increasingly rare). Emphasize that LWC is the future.

Explain that data flows from parent to child using public properties decorated with `@api`. Provide an example of a parent passing data to a child. For child-to-parent communication, explain using custom events. Describe how the child dispatches a `CustomEvent` (e.g., `this.dispatchEvent(new CustomEvent('myevent', { detail: myData }))`) and how the parent listens for it in its HTML template (e.g., `<c-child-component onmyevent={handleMyEvent}></c-child-component>`). Mention the importance of `detail` for passing data with the event.

Start by outlining the integration's purpose, the systems involved, and the data flow (e.g., 'Integrating Salesforce with an external ERP for order processing'). Detail the technologies used (REST/SOAP API, Platform Events, Middleware). Then, focus on specific challenges: authentication (OAuth, JWT), data mapping/transformation, error handling (retries, logging), governor limits, performance, or ensuring data consistency. Explain the solutions you implemented, e.g., using a custom logging framework, implementing a retry mechanism with exponential backoff, or leveraging Queueable Apex for asynchronous processing. Quantify the impact if possible.

Explain that Platform Events and CDC are event-driven, real-time (or near real-time) integration patterns, ideal for scenarios where external systems need to react to changes in Salesforce without constant polling. Contrast this with traditional API callouts, which are often request-response based. Detail when to use Platform Events: custom events, decoupling systems, broadcasting events to multiple subscribers, or when you need a custom payload. Detail when to use CDC: when you need to track changes to standard or custom Salesforce objects (create, update, delete, undelete) and replicate them to external systems with minimal configuration. Emphasize their scalability and reduced API call limits compared to polling.

Start by defining Salesforce DX as a set of tools for source-driven development, emphasizing scratch orgs, CLI, and version control. Explain CI/CD (Continuous Integration/Continuous Delivery) as automating the build, test, and deployment process. Describe your experience: 'I've used Salesforce DX to manage source code in Git, create scratch orgs for isolated development, and run automated tests.' For CI/CD, mention specific tools (e.g., Jenkins, GitLab CI, Azure DevOps) and how you've configured pipelines to automatically run Apex tests, static code analysis, and deploy metadata to various environments upon code merge. Highlight benefits like faster deployments, reduced errors, improved code quality, and better team collaboration.

For quality and scalability, mention adhering to Apex best practices (e.g., bulkification, avoiding SOQL/DML in loops, proper error handling, using custom settings/metadata for configurable values, adhering to governor limits). For testing, explain writing comprehensive Apex unit tests with at least 75% code coverage. Detail strategies: testing positive and negative scenarios, bulk data scenarios, testing with different user profiles/permissions, and using `System.runAs()` for security context. Mention using `Test.startTest()` and `Test.stopTest()` for governor limit resets and asynchronous testing. Emphasize that tests should validate business logic, not just achieve coverage.

Start by clarifying requirements: 'First, I'd gather detailed requirements on each approval step, conditions, approvers, and rejections.' Then, discuss leveraging declarative tools first: 'I'd evaluate if standard Approval Processes or Flows (Record-Triggered Flow with Subflows for complex logic) can handle the routing and conditions.' If declarative limits are hit, then introduce Apex: 'For highly dynamic routing, external approvals, or complex calculations not supported by Flow, I'd consider a custom Apex solution, possibly using a custom object to manage approval steps and statuses, and integrating with a Flow for user interface and initial triggering.' Mention considerations like audit trails, notifications, and re-submission logic. Emphasize a hybrid approach if suitable.