96 Salesforce Technical Consultant Interview Questions & Answers (2026) | SF Interview Pro

⚡ SF Interview Pro · Home › Interview Q & A › Technical Consultant

💼 Role-Based · Technical Consultant

96 Salesforce Technical Consultant Interview Questions & Answers (2026)

Real technical consultant interview rounds (security, async Apex, integration, LWC) plus client-facing scoping and delivery scenarios — everything a consultant-level interview actually covers

96Questions

6Rounds Covered

100%Free

⚡ Complete Index — All 96 Questions

1What do you understand by Salesforce, and how is it different from... 2Explain the entire Salesforce security model in brief.... 3What is Apex-managed sharing? Describe a scenario where you've... 4What is the maximum trigger depth in Salesforce, and how does it... 5How can you avoid recursive triggers? (Interviewers expect more... 6Do you have experience with design patterns like Singleton or... 7What kind of integration scenarios have you worked on, and what do... 8What are the different annotations used in Apex test classes?... 9What is one scenario where you'd actually use seeAllData=true in a... 10Can you access Custom Metadata Type records in Apex test classes... 11What is Test.startTest() and Test.stopTest()?... 12You wrote a test class for a Batch class, calling... 13Can you call a Queueable job from another Queueable job?... 14Can you call a Queueable job from a Batch Apex job?... 15How many Queueable jobs can you chain from a Queueable, and how... 16What is Queueable chaining and when would you use it?... 17What are the overall best practices of Apex you'd bring into a... 18I have a large JSON object being displayed in an LWC, and changes... 19Wire vs imperative Apex calls — is wire reactive by default, and... 20What is LWC OSS, and have you worked with it?... 21Given a JSON payload, how would you create a wrapper class and... 22With sharing, without sharing, and inherited sharing in Apex — how... 23Walk through a deep dive of your current project — why did you... 24You mentioned CTI integration — how is call log generation handled... 25How have you handled edge cases in code you've written, specific... 26What error retry and error logging mechanisms do you use when... 27What's the performance impact of using @track decorators in LWC?... 28Explain an integration scenario you've worked on end-to-end,... 29Have you worked on setting up SSO (Single Sign-On)? What's your... 30Have you worked with Git commands as part of your deployment process?... 31You have a Batch job on Accounts where, for each Account... 32You have an LWC displaying data to an unauthenticated Guest User... 33If that same unauthenticated user wants to create or update... 34You have an Apex method you want to call with sharing for internal... 35How do you deal with external teams that have a different style of... 36Suppose you're the only expert on a certain module in your project... 37All your upcoming sprints are planned, and the client suddenly... 38What are the drawbacks of Change Sets as a deployment tool?... 39Have you also worked on resolving production incidents (L2 support)?... 40How do you manage object-level and field-level security in... 41Scenario: You created a Permission Set giving Edit access on Case... 42How do you share a Job__c record with a public Queue using Apex?... 43You want to query all Contacts and Leads in your org with a... 44Your org has a marketing and sales team both creating... 45Define Matching Rules and Duplicate Rules and how they relate to... 46What is the difference between the Time Component and Variant... 47Explain the different ways to handle asynchronous execution in Apex.... 48You are required to communicate information to a third-party... 49When would you use Queueable Apex, and how do you handle it in... 50Explain the difference between synchronous and asynchronous... 51If asynchronous execution runs in a separate thread and you don't... 52You're calling a future method and need to write unit tests for... 53One of your classes doesn't individually have 75% code coverage,... 54Explain DML Exceptions in detail, and what are Setup versus... 55In your test class, you create a User (a Setup object) and, in the... 56You have a batch that runs nightly on Accounts and processes them.... 57A feature worked fine in every lower environment (Dev, QA, UAT),... 58How do you authorize an external endpoint in Salesforce generally,... 59The sales manager wants to see the average Amount from all Closed... 60You need to ensure Shipping Address is never left blank when... 61Every time an Account's Active field is changed to false, you need... 62What advice would you give a customer with little to no Salesforce... 63What are your top three tips to improve user adoption on a... 64What's your best-practice advice for maintaining clean data in... 65Explain the core differences between Sales Cloud and Service Cloud.... 66What are the fundamental skill differences between a Salesforce... 67What are the benefits of the Salesforce AppExchange in a client... 68How would you explain what Salesforce is to a completely... 69What are your tips for communicating technical concepts to... 70How would you support a client who is very resistant to change... 71List three critical success factors for a new Salesforce... 72What are common causes of project scope creep, and how do you... 73Describe a use case for enabling the Person Accounts feature.... 74Scenario: An Account object has fields both a customer support... 75What is the difference between a Role and a Profile in Salesforce?... 76What are the main limitations of Salesforce Professional Edition... 77What are three metrics or reports every Sales Manager should have... 78A client has used 121% of their Salesforce data storage limit and... 79A client manually creates quotes in Word using a separate Excel... 80How do you approach a large-scale data migration project, such as... 81How does Salesforce Financial Services Cloud typically integrate... 82A client's Salesforce org has grown to 40+ Apex triggers built by... 83During discovery, a client insists they need a fully custom-built... 84You're proposing a solution that requires a platform license... 85Midway through a project, the client's internal admin who was your... 86A client wants real-time inventory sync between Salesforce and an... 87The client's Sales team and Support team disagree on what... 88A client's org has Apex CPU timeout errors happening... 89How do you handle a situation where the client's chosen... 90You're asked to estimate a complex multi-cloud (Sales Cloud +... 91A long-time client asks you to bypass your own recommended... 92How would you evaluate whether a client's requirement should be... 93A client's previous consultancy left behind a Salesforce org with... 94How do you handle disagreement with a client stakeholder about the... 95Your client wants a phased go-live (Sales Cloud first, Service... 96A client asks you to recommend whether they should build a custom...

🔐

Round 1 — Security, Sharing & Apex Fundamentals

Q1–Q22 · The technical screening round: security model, sharing, recursion, testing, and LWC basics

Q001Round 1

What do you understand by Salesforce, and how is it different from any other database application?

Salesforce is a cloud-based CRM platform built on a multi-tenant architecture with a metadata-driven data model — unlike a raw database, it ships with built-in security, automation, UI, and APIs out of the box.

🔑 Key Points

A traditional database only stores data; Salesforce layers security (profiles, sharing), automation (Flow, Apex), and a full UI framework on top of that data model, all configurable declaratively before you write a line of code. The metadata-driven approach also means schema changes (new fields, objects) propagate instantly across UI, API, and reporting without a separate migration script.

🌍 Example

A consulting client comparing Salesforce to a custom SQL database usually underestimates how much of their "custom app" — auth, audit trail, mobile access, reporting — comes free with the platform, which is often the strongest cost-justification point in a build-vs-buy conversation.

Q002Round 1

Explain the entire Salesforce security model in brief.

Security layers from broad to narrow: Org-level (login hours/IP ranges) → Object-level (Profiles/Permission Sets) → Field-level (FLS) → Record-level (OWD, Role Hierarchy, Sharing Rules, Manual/Apex-managed sharing).

🔑 Key Points

Ownership always wins — a record owner can see and edit their own record regardless of OWD. Permission Sets only ever add access on top of a Profile, never remove it. The record-level layer is evaluated last and is cumulative — a user gets the widest access granted by any single mechanism (role hierarchy OR a sharing rule OR manual sharing), not the narrowest.

🌍 Example

A sales rep who owns an Opportunity can always edit it even if OWD for Opportunity is Private and no sharing rule exists — ownership is the one access grant that bypasses every other layer.

Q003Round 1

What is Apex-managed sharing? Describe a scenario where you've used it.

Apex-managed sharing lets you grant record access programmatically by inserting rows into an object's Share table (e.g. Case__Share), used when the access logic is too complex for a declarative sharing rule.

🔑 Key Points

You need an Apex Sharing Reason defined on the object first. Unlike sharing rules, Apex sharing survives ownership changes only if you explicitly recompute it on change — this is the detail most candidates miss, and interviewers specifically probe for it.

🌍 Example

A field service org shares a Work Order with any technician within 50 miles of the job site — a geo-radius condition no standard sharing rule can express, so a scheduled Apex job recalculates and re-inserts WorkOrder__Share rows nightly as technicians' territories shift.

insert new Case__Share(CaseId = c.Id, UserOrGroupId = techId, CaseAccessLevel = 'Edit', RowCause = 'Nearby_Technician__c');

Q004Round 1

What is the maximum trigger depth in Salesforce, and how does it relate to recursion?

Salesforce allows up to 16 levels of nested trigger invocation (e.g. Trigger A updates a record that fires Trigger B, and so on) before it throws a runtime error to prevent infinite loops.

🔑 Key Points

This limit exists as a safety net, not a design target — a well-built trigger framework with recursion guards should never get anywhere close to it. Hitting the depth limit in production almost always signals a genuine architecture problem (circular cross-object triggers) rather than bad luck.

🌍 Example

Two objects with triggers that each update the other (Account updates Contact, Contact trigger updates Account back) will climb the stack depth every single transaction — a recursion guard on at least one side is mandatory, not optional, in that design.

Q005Round 1

How can you avoid recursive triggers? (Interviewers expect more than just a static Boolean.)

A static Boolean flag works for simple single-pass recursion, but the more robust pattern is a static Set of "already processed" record Ids checked at the top of the trigger handler, so partial reprocessing within the same transaction is still handled correctly.

🔑 Key Points

A single static Boolean can wrongly block a legitimate second update to a *different* record in the same transaction — a static Set of processed Ids is precise per-record instead of blunt per-transaction. For very complex cross-object recursion chains, a static recursion-depth counter combined with the Id set gives you both loop prevention and a hard ceiling.

🌍 Example

Account trigger updates a Contact, which fires a Contact trigger that updates the same Account again — a Set guard lets the second Account update through only if it's a genuinely different record, or exits cleanly if not.

private static Set processedIds = new Set(); for (Account acc : Trigger.new) { if (processedIds.contains(acc.Id)) continue; processedIds.add(acc.Id); // trigger logic }

Q006Round 1

Do you have experience with design patterns like Singleton or Factory in Apex?

Singleton is used to guarantee a single shared instance of a config/utility object across a transaction; Factory is used to instantiate different handler classes dynamically based on a type (e.g. Record Type or object name) without a long if/else chain.

🔑 Key Points

A Trigger Handler Factory pattern is extremely common in enterprise Salesforce orgs — one dispatcher class maps SObjectType to its corresponding handler class via a Map, keeping the trigger itself to a single line. Singleton is also useful for caching an expensive Custom Metadata or Custom Setting lookup once per transaction instead of re-querying it in every method that needs it.

🌍 Example

A multi-object trigger framework uses a Factory to return the correct TriggerHandler implementation based on Trigger.new's SObjectType, so adding a new object never means editing the dispatcher — only registering one new Map entry.

public class TriggerHandlerFactory { private static Map<String, ITriggerHandler> handlers = new Map<String, ITriggerHandler>{ 'Account' => new AccountTriggerHandler(), 'Contact' => new ContactTriggerHandler() }; public static ITriggerHandler getHandler(String objType) { return handlers.get(objType); } }

Q007Round 1

What kind of integration scenarios have you worked on, and what do you mean by point-to-point integration?

Point-to-point integration is a direct, one-to-one connection between two systems (e.g. Salesforce calling a shipping API directly) with no middleware layer in between — simple to set up but harder to scale as the number of connected systems grows.

🔑 Key Points

Point-to-point works fine for 2-3 systems; beyond that, the number of direct connections grows quadratically, which is exactly when a middleware/ESB layer like MuleSoft becomes worth the added complexity. The tradeoff isn't just connection count — point-to-point also means every one of those systems needs to independently handle Salesforce's auth, rate limits, and retry logic, which middleware centralizes once.

🌍 Example

A retailer connecting Salesforce directly to one payment gateway is a clean point-to-point integration; the same retailer connecting to five different regional payment providers, a shipping API, and an ERP is where middleware starts paying off — otherwise five separate teams are each independently reinventing retry and auth logic.

Q008Round 1

What are the different annotations used in Apex test classes?

@isTest marks a class or method as test-only (excluded from org code size limits), @testSetup creates shared test data once per class, @TestVisible exposes private members to test code, and Test.startTest()/stopTest() force asynchronous work to run synchronously during assertions.

🔑 Key Points

@testSetup runs once before every test method in the class, not once total — each test method gets a fresh rollback to that setup state, so tests stay isolated from each other even though they share the same setup data source. @TestVisible is specifically useful for unit-testing a private helper method without exposing it to production callers.

🌍 Example

A trigger handler class with a private validateAmount() helper marks it @TestVisible so a dedicated test method can assert its logic in isolation, without having to trigger the entire DML flow just to exercise that one method.

Q009Round 1

What is one scenario where you'd actually use seeAllData=true in a test class?

Almost never for custom data — the one legitimate case is testing against genuinely static, pre-existing organization-wide reference data that can't be created in a test context, like certain standard picklist metadata or existing Currency records in a multi-currency org.

🔑 Key Points

Relying on seeAllData=true is a code smell in almost every other case — it makes tests fragile and dependent on production data that could change or be deleted, breaking CI pipelines unpredictably. A strong interview answer explicitly names this as an anti-pattern before giving the narrow legitimate exception.

🌍 Example

A test validating currency conversion math against the org's actual configured exchange rates (which can't be inserted via DML) is one of the few defensible seeAllData=true use cases, since CurrencyType records are org-wide static configuration, not transactional data.

Q010Round 1

Can you access Custom Metadata Type records in Apex test classes without seeAllData=true? What about Custom Settings?

Yes to both — Custom Metadata Type records are automatically visible in test context without seeAllData=true since they're metadata, not data; Custom Settings similarly don't require seeAllData=true because they're treated as configuration rather than transactional data.

🔑 Key Points

This is a frequently-missed distinction: Custom Metadata deploys and is visible everywhere by default in tests, while regular custom object records absolutely do need explicit test data setup or seeAllData=true. This is also exactly why Custom Metadata is the preferred config-storage mechanism over Custom Settings in new development — it behaves more predictably across test and deployment contexts.

Q011Round 1

What is Test.startTest() and Test.stopTest()?

They delineate a separate governor-limit context within a test method — code between startTest() and stopTest() gets a fresh set of limits, and any asynchronous Apex enqueued inside that block (future, Queueable, Batch) executes synchronously the moment stopTest() is called.

🔑 Key Points

This is the mechanism that lets you actually assert on the results of an async operation within the same test method — without stopTest(), the async job would still be "pending" when your assertions run. You can only call startTest()/stopTest() once each per test method; nesting or repeating them throws a runtime exception.

🌍 Example

A test inserting 500 Accounts to exercise a real bulk trigger scenario places the insert between startTest() and stopTest() specifically to get a clean fresh governor-limit budget for that bulk operation, isolated from any setup DML that ran before it.

Q012Round 1

You wrote a test class for a Batch class, calling Database.executeBatch() with an instance of the batch, but you're only getting code coverage for the start() method. What's the likely cause?

The test isn't wrapped in Test.startTest()/Test.stopTest() — without that wrapper, the batch job is only enqueued, not actually executed synchronously, so execute() and finish() never run during the test.

🔑 Key Points

Coverage tools can only credit lines that actually executed during the test run — a batch job that's merely queued but never forced to run via stopTest() leaves execute()/finish() completely uncovered, even though the test appears to "pass" since executeBatch() itself doesn't throw an error.

Test.startTest(); Database.executeBatch(new MyBatchClass(), 200); Test.stopTest(); // batch actually runs here, synchronously

Q013Round 1

Can you call a Queueable job from another Queueable job?

Yes — this is called Queueable chaining, and it's one of Queueable Apex's key advantages over future methods, which cannot chain at all.

🔑 Key Points

From within an already-executing Queueable job, you're limited to enqueueing exactly one additional chained job — this cap exists specifically to prevent an unbounded recursive chain from silently running forever.

🌍 Example

A multi-step data enrichment pipeline chains three Queueable jobs sequentially — fetch external data, transform it, then write results — each step getting a fresh governor-limit budget instead of cramming all three into one transaction.

Q014Round 1

Can you call a Queueable job from a Batch Apex job?

Yes, typically from the finish() method of the batch, commonly used to kick off a follow-up notification or cleanup job once the main batch processing completes.

🔑 Key Points

This is the standard pattern for "batch completed, now do one more thing" workflows — like sending a summary email or triggering a secondary reconciliation pass — without bloating the batch's own execute() method with unrelated post-processing logic.

Q015Round 1

How many Queueable jobs can you chain from a Queueable, and how many from a synchronous context?

From within an already-running Queueable (async context), you can only chain one additional job per execution. From a synchronous context (like a button click or a trigger), you can enqueue up to 50 Queueable jobs in that single transaction.

🔑 Key Points

This 1-job-per-async-chain limit is specifically designed to prevent runaway recursive chaining that could otherwise queue indefinitely, while the more generous 50-job synchronous limit acknowledges that a single user action might legitimately need to kick off several independent parallel jobs at once.

Q016Round 1

What is Queueable chaining and when would you use it?

Chaining is enqueueing a new Queueable job from inside the execute() method of a currently running one, used to break a large sequential process into multiple governor-limit-safe transactions.

🔑 Key Points

Each chained job gets a brand new set of governor limits, which is exactly why chaining is the right tool for a multi-step process too large to fit in one transaction's limits — like processing 10,000 records where each step needs its own full SOQL/DML budget.

🌍 Example

A data cleanup job processing 200,000 records in 2,000-record chunks chains itself repeatedly until the full dataset is processed, with each chained execution starting completely fresh rather than accumulating limit usage across the whole run.

public void execute(QueueableContext context) { // do step 1 if (moreWorkRemains) { System.enqueueJob(new NextStepQueueable()); } }

Q017Round 1

What are the overall best practices of Apex you'd bring into a consulting engagement?

Bulkify everything (no SOQL/DML in loops), one trigger per object routed through a handler class, enforce CRUD/FLS/sharing explicitly, avoid hardcoding Ids, and keep business logic out of the trigger itself.

🔑 Key Points

In a consulting context specifically, add: document *why* a design decision was made (not just what), since the next developer inheriting the org almost never has access to the original requirements conversation. Also worth naming explicitly: consistent naming conventions and a shared code review checklist, since consulting teams rotate developers on and off projects far more often than in-house teams.

🌍 Example

A consultant handing off a completed project should leave behind a short design-decisions document explaining, for example, why a particular rollup was built in Apex instead of a native roll-up summary field — saving the next developer hours of reverse-engineering intent from code alone.

Q018Round 1

I have a large JSON object being displayed in an LWC, and changes made to the JSON aren't reflecting in the UI. What could be the reason?

The JSON was very likely mutated in place (e.g. pushing into a nested array or setting a nested property directly) rather than reassigned as a fresh object — LWC's reactivity only detects top-level reassignment, not deep in-place mutation.

🔑 Key Points

This is one of the most common LWC bugs even among experienced developers, precisely because it works fine in plain JavaScript and only breaks due to LWC's specific reactivity model. For a full breakdown of LWC reactivity, decorators, and lifecycle hooks, see our dedicated LWC Interview Questions guide.

🌍 Example

A component displaying a nested cart object where items are pushed directly into cart.items shows a stale UI even though the underlying array genuinely changed — spreading into a fresh object on every update fixes it immediately.

// Wrong -- mutates in place, won't trigger re-render: this.data.items.push(newItem); // Right -- reassigns a fresh object: this.data = { ...this.data, items: [...this.data.items, newItem] };

Q019Round 1

Wire vs imperative Apex calls — is wire reactive by default, and if not, how do you make it reactive?

A @wire property IS reactive by default for its parameters — it automatically re-fires whenever a $-prefixed reactive parameter changes; an imperative call never auto-refires and has to be triggered manually.

🔑 Key Points

The reactivity is scoped specifically to the parameters passed into the wire adapter, not the wired method's internal logic — changing an unrelated property on the component won't cause a re-fire unless it's one of the actual wired parameters. See the LWC Interview Questions guide for the full wire vs imperative comparison including caching behavior.

🌍 Example

A wired getContactsForAccount({accountId: '$recordId'}) automatically re-queries the moment recordId changes as the user navigates between records, with zero manual refresh logic needed.

Q020Round 1

What is LWC OSS, and have you worked with it?

LWC OSS (Open Source) is the framework-agnostic, standalone version of Lightning Web Components that can run outside Salesforce entirely — usable in any web project, not just on the Salesforce platform.

🔑 Key Points

It's the same core compiler and reactivity engine Salesforce itself uses internally, released so the broader web community can build LWC-based apps independent of the Salesforce platform. Knowing it exists (even without hands-on production use) signals awareness of where the framework is headed beyond just the Salesforce ecosystem.

Q021Round 1

Given a JSON payload, how would you create a wrapper class and update a custom object in Salesforce?

Deserialize the JSON into a strongly-typed Apex wrapper class matching its structure using JSON.deserialize(), then map the wrapper's fields onto the target sObject before performing DML.

🔑 Key Points

Field names in the wrapper class must match the JSON keys exactly (case-sensitive) unless you use @JsonAccess or manual parsing — a common integration bug is a silent null field from a case mismatch. For payloads with an unpredictable or evolving schema, JSON.deserializeUntyped() into a Map is more resilient than a rigid wrapper class, at the cost of losing compile-time type safety.

🌍 Example

An inbound webhook from a payment processor deserializes into an OrderWrapper class, and any field the processor renames in a future API version fails loudly at deserialization time rather than silently dropping data — arguably a feature, not just a risk, since it surfaces the break immediately.

public class OrderWrapper { public String orderId; public Decimal amount; } OrderWrapper ow = (OrderWrapper) JSON.deserialize(jsonString, OrderWrapper.class); Order__c o = new Order__c(External_Id__c = ow.orderId, Amount__c = ow.amount); insert o;

Q022Round 1

With sharing, without sharing, and inherited sharing in Apex — how are without sharing and inherited sharing different?

without sharing always ignores the running user's sharing rules regardless of caller context; inherited sharing instead adopts the sharing mode of whatever class called it, defaulting to with sharing only when it's the actual entry point of the transaction.

🔑 Key Points

inherited sharing exists specifically for reusable utility/library classes — it lets the same class behave securely when called from a with sharing context and permissively when deliberately called from a without sharing one, without needing two copies of the class. This matters a lot in consulting handoffs, since a shared utility library often gets called from many different contexts across a large org that the original author never anticipated.

🌍 Example

A generic "get related records" utility class marked inherited sharing behaves securely when called from a standard Community-facing controller, but correctly runs permissively when explicitly invoked from an admin data-migration script marked without sharing — one class, two correct behaviors depending on who's calling it.

🔗

Round 2 — Project Deep Dive & Integration

Q23–Q34 · Real project cross-questioning: error handling, SSO, Guest User security, integration flows

Q023Round 2

Walk through a deep dive of your current project — why did you make the decisions you made, and what would you do differently?

This is a consulting-specific behavioral question testing whether you can critically evaluate your own past architecture decisions, not just describe what was built.

🔑 Key Points

Structure the answer as: the constraint that drove the decision → the tradeoff you accepted knowingly → what you'd change now with hindsight or new platform features available today. Naming a genuine "I'd do this differently now" shows intellectual honesty interviewers specifically listen for — a purely defensive answer with no self-critique is actually a red flag.

🌍 Example

"We built a custom Apex rollup instead of using a roll-up summary field because the relationship was a lookup, not master-detail — with hindsight, I'd revisit whether converting to master-detail was viable early on, since it would have eliminated 200 lines of trigger code we've maintained ever since."

Q024Round 2

You mentioned CTI integration — how is call log generation handled in Salesforce via standard APIs?

Open CTI (Computer-Telephony Integration) exposes a JavaScript API that call center softphones use to programmatically create Task or Voice Call records logging call metadata (duration, disposition, recording URL) against the relevant Lead/Contact/Case.

🔑 Key Points

The actual call log record creation is typically triggered client-side by the softphone's JS layer calling Salesforce's REST/Open CTI APIs the moment a call ends, not via a separate batch reconciliation process — meaning the call record exists essentially in real time, which matters for supervisors monitoring live queues.

🌍 Example

A support call center's softphone widget calls sforce.interaction.cti.enableClickToDial() and, on call completion, programmatically inserts a Task with the recording URL and disposition code — all without the agent manually logging anything.

Q025Round 2

How have you handled edge cases in code you've written, specific to a real project?

Answer with a concrete example: a null/empty-collection edge case, a partial-failure edge case in bulk DML, or a race-condition edge case in a high-concurrency trigger — showing the specific defensive code you added.

🔑 Key Points

Interviewers are listening for whether you found the edge case proactively during design/code review, versus reactively after a production incident — both are valid answers, but say which one it was, since it shows either strong upfront design discipline or genuine incident-response learning.

🌍 Example

A trigger summing Opportunity amounts onto Account assumed every Opportunity always had an AccountId — a null-check edge case surfaced in production when a data migration briefly created orphaned Opportunities, and the fix added an explicit null guard plus a validation rule preventing the orphan state going forward.

Q026Round 2

What error retry and error logging mechanisms do you use when inserting data into the database via Apex?

Use Database.insert(records, false) (allOrNone=false) to get partial success with a Database.SaveResult array per record, log failures to a custom Error_Log__c object with the specific error message and failed record data, and implement a scheduled retry batch for transient failures.

🔑 Key Points

Never let a bulk operation's partial failures pass silently — always inspect the SaveResult array and persist enough detail (record data + error message) that someone can actually diagnose and reprocess the failure later. Distinguish transient errors (row lock, timeout — safe to auto-retry) from permanent ones (validation rule failure — needs human review) so your retry batch doesn't waste cycles endlessly retrying something that will never succeed.

🌍 Example

A nightly integration processes 50,000 external records; the 200 that fail due to row-lock contention get automatically requeued for the next run, while the 15 that fail validation get flagged in an Error_Log__c record an admin reviews the next morning.

Database.SaveResult[] results = Database.insert(records, false); for (Integer i = 0; i < results.size(); i++) { if (!results[i].isSuccess()) { // log records[i] and results[i].getErrors() to Error_Log__c } }

Q027Round 2

What's the performance impact of using @track decorators in LWC?

Since Spring '20, @track is largely unnecessary for reactivity on primitive fields — overusing it on large objects/arrays can add unnecessary deep-observation overhead compared to simply reassigning a fresh object when it changes.

🔑 Key Points

The performance cost is subtle rather than dramatic in most components, but on data-heavy components (large tables, deeply nested wrappers) unnecessary @track usage can measurably slow re-renders. See the LWC Interview Questions guide for the full reactive-binding breakdown.

Q028Round 2

Explain an integration scenario you've worked on end-to-end, including the authentication technique used.

Structure the answer around the full flow: Named Credential setup → OAuth 2.0 grant type chosen and why (e.g. JWT Bearer for unattended server-to-server) → the actual HTTP callout code → response handling and error/retry logic.

🔑 Key Points

Naming the specific OAuth grant type and justifying why that one (not just "we used OAuth") is what separates a strong answer from a vague one in a consultant-level interview — it demonstrates you actually made an informed integration-architecture decision rather than defaulting to whatever the last project used.

🌍 Example

A nightly inventory sync to a partner ERP used JWT Bearer Flow specifically because there was no human available to complete an interactive login at 2 AM — the alternative Web Server Flow would have required a refresh token that could silently expire and break the whole pipeline unattended.

Q029Round 2

Have you worked on setting up SSO (Single Sign-On)? What's your understanding of it?

SSO lets users authenticate once through a central Identity Provider (IdP) and access Salesforce (and other connected apps) without a separate login — configured in Salesforce as a Service Provider (SP) via SAML or OpenID Connect.

🔑 Key Points

Salesforce can act as either the IdP or the SP depending on the architecture — most enterprise consulting engagements have Salesforce as the SP, federating identity from a corporate IdP like Okta or Azure AD. "Just-in-time" (JIT) provisioning is a useful detail to mention — it auto-creates the Salesforce user record on first SSO login rather than requiring a separate manual user-creation step.

🌍 Example

A large enterprise client federates 5,000 employees' Salesforce access through their existing Okta IdP, with JIT provisioning automatically creating new Salesforce user records the first time a newly onboarded employee logs in — no separate Salesforce admin step required per new hire.

Q030Round 2

Have you worked with Git commands as part of your deployment process?

Yes — standard flow: feature branch → commit → push → pull request → code review → merge to a release branch → CI/CD pipeline deploys via Salesforce DX or a tool like Copado/Gearset.

🔑 Key Points

Being specific about your branching strategy (git-flow vs trunk-based) and how merge conflicts in metadata (like Flow XML) get resolved shows real hands-on experience, not textbook knowledge. Flow and Permission Set XML conflicts specifically tend to be painful to resolve manually since they're not line-oriented like Apex — worth naming this as a known friction point.

🌍 Example

A team using trunk-based development with short-lived feature branches resolves a Flow XML merge conflict by having one developer regenerate their Flow changes cleanly on top of the latest main branch rather than attempting a manual line-by-line XML merge, which is notoriously error-prone.

Q031Round 2

You have a Batch job on Accounts where, for each Account processed, you need to send an email AND check a checkbox on the Account. Where would you send the email — execute() or finish() — and would you hit governor limits?

Send the email from execute() per-scope using Messaging.sendEmail() in bulk (one call per batch chunk, not per record), and update the checkbox in the same execute() transaction — sending from finish() would only let you email once total, not per Account.

🔑 Key Points

Governor limits reset per execute() chunk, so as long as you batch the email-sending call itself (passing a List) rather than looping individual sends, you stay well within the single-email-per-transaction-type limits. Watch specifically for the daily org-wide email limit if the batch runs across a very large dataset — that's an org-level cap, not a per-transaction one, and batching within execute() doesn't protect against it.

global void execute(Database.BatchableContext bc, List<Account> scope) { List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>(); for (Account acc : scope) { acc.Processed__c = true; emails.add(buildEmail(acc)); } update scope; Messaging.sendEmail(emails); }

Q032Round 2

You have an LWC displaying data to an unauthenticated Guest User in a Community. How do you give the user permission to see and display that data?

Grant the Guest User Profile explicit object and field-level read access, and set the object's external OWD appropriately (Guest User access defaults to very restrictive since Winter '21) — never over-grant beyond exactly what that public page needs.

🔑 Key Points

Guest User security misconfiguration is one of the most serious real-world data-exposure risks in Salesforce — treat every permission granted to this profile as if it's visible to the entire internet, because it effectively is. Always test the exact scenario logged out in an incognito browser window before go-live, since it's easy to accidentally test with residual authenticated session access.

🌍 Example

A product catalog page publicly visible to anonymous visitors grants the Guest Profile Read access to exactly the Product2 fields displayed — Name, Price, Description — and nothing else, even though the underlying Product2 object has 40 other internal fields the Guest Profile never touches.

Q033Round 2

If that same unauthenticated user wants to create or update records, how do you grant that access?

Guest Users can be granted Create/Edit object permissions on the Guest Profile directly, but this must be paired with strict validation rules and ideally a without sharing Apex layer that enforces exactly which fields can be set, since Guest Users have no real identity to audit against.

🔑 Key Points

Never let a Guest User's create/update path touch sensitive fields directly — route it through an Apex controller that whitelists exactly the fields the public form is allowed to submit, ignoring anything else in the incoming payload even if a malicious actor tries to inject additional field values via a modified request.

🌍 Example

A public "Request a Quote" form on a Community page lets Guest Users create a Lead, but the Apex controller behind it explicitly sets only Name, Email, and Company from the form input, silently discarding any other fields a tampered request might attempt to set.

Q034Round 2

You have an Apex method you want to call with sharing for internal authenticated users, but without sharing for unauthenticated Guest Users. How would you achieve that?

Check the running user's context inside the method (e.g. UserInfo.getUserType() == 'Guest') and branch into calling a without sharing inner/helper class only for that case, keeping the outer class with sharing by default for authenticated users.

🔑 Key Points

This pattern — one method, two sharing contexts based on caller identity — is exactly what inherited sharing was designed to simplify, worth mentioning as the more modern alternative to manual branching. The key risk to flag explicitly: whichever branch runs without sharing needs its own tight, hand-verified access boundary since it's bypassing the platform's automatic enforcement entirely.

public with sharing class DataService { public static List<Account> getAccounts() { if (UserInfo.getUserType() == 'Guest') { return GuestHelper.getAccountsWithoutSharing(); } return [SELECT Id, Name FROM Account]; } } public without sharing class GuestHelper { public static List<Account> getAccountsWithoutSharing() { return [SELECT Id, Name FROM Account WHERE Public__c = true]; } }

🧭

Round 3 — Techno-Managerial & Delivery

Q35–Q39 · Agile delivery, team leadership, incident response, and deployment process

Q035Round 3

How do you deal with external teams that have a different style of functioning and different delivery timelines?

Establish a shared communication cadence early (joint standups or a weekly sync), document interface contracts explicitly (API specs, data formats) so teams aren't blocked waiting on tribal knowledge, and build in buffer time around known cross-team dependencies.

🔑 Key Points

The real risk with external/offshore teams isn't skill — it's timezone-driven latency on blocking questions; proactively documenting assumptions in writing reduces the number of round-trips needed, since a single blocked question across a 10-hour timezone gap can cost an entire working day.

🌍 Example

Two teams across a 9-hour timezone gap agree on a written interface contract for a shared integration before either side writes code, eliminating what would otherwise be a multi-day round-trip clarification loop mid-sprint.

Q036Round 3

Suppose you're the only expert on a certain module in your project and, for some reason, are unable to attend work. What would you do?

Proactively maintain a living design/runbook document for that module *before* the situation arises, and pair-program or do a knowledge-transfer session periodically so at least one other team member has working familiarity.

🔑 Key Points

Bus-factor risk is a real project management concern clients specifically probe for in consultant interviews — the answer they want is prevention, not just "I'd document it if asked." Mentioning a specific practice (e.g. rotating code review assignments so at least two people touch every module) shows this is a habit, not a hypothetical.

🌍 Example

A consultant who's the sole expert on a complex CPQ pricing engine schedules a recurring monthly walkthrough with a teammate specifically so the bus-factor risk never grows unaddressed for months at a time.

Q037Round 3

All your upcoming sprints are planned, and the client suddenly needs a priority requirement pulled into an earlier sprint, but your team is out of capacity. How do you handle it?

Present the tradeoff transparently to the client/product owner: what has to be deprioritized or pushed out if this goes in now, and let them make the informed call rather than silently overcommitting the team.

🔑 Key Points

Never just silently absorb the extra scope — that erodes estimation credibility for every future sprint and normalizes unsustainable pace, which is a bigger long-term problem than one difficult client conversation. Framing it as "here are your two options and their tradeoffs" rather than "we can't do it" keeps the conversation collaborative instead of adversarial.

🌍 Example

A client's urgent compliance requirement gets prioritized into the current sprint, but the consultant explicitly shows which lower-priority story is being bumped to next sprint as the tradeoff — turning what could be a conflict into a joint decision.

Q038Round 3

What are the drawbacks of Change Sets as a deployment tool?

Change Sets are manual, one environment-pair at a time, have no rollback capability, don't handle destructive changes well, and provide zero automated testing or CI/CD integration — making them impractical at team scale.

🔑 Key Points

Most consulting engagements past a certain team size move to Salesforce DX with a real CI/CD pipeline (GitHub Actions, Copado, Gearset) specifically to escape these Change Set limitations. The lack of rollback is often the most painful in practice — a bad Change Set deployment to Production has no "undo," only a manually crafted reverse deployment.

🌍 Example

A mid-size consultancy running 6 parallel workstreams into the same org abandons Change Sets entirely for a source-driven Salesforce DX pipeline once conflicting manual Change Sets between two developers start silently overwriting each other's work.

Q039Round 3

Have you also worked on resolving production incidents (L2 support)?

Answer with a specific incident: how it was triaged (severity/impact assessment), root-caused (debug logs, error logging), the immediate mitigation applied, and the permanent fix plus any process change to prevent recurrence.

🔑 Key Points

Structuring the answer as Triage → Mitigate → Root Cause → Permanent Fix → Prevention shows incident-response maturity beyond just "I fixed the bug." The "prevention" step specifically is what separates a senior answer from a junior one — showing you closed the loop so the same class of incident can't recur.

🌍 Example

A production trigger recursion incident was mitigated within 20 minutes via a Custom Setting kill-switch, root-caused to a missing recursion guard on a recently deployed feature, permanently fixed with a Set guard, and prevented going forward by adding a recursion-guard check to the team's code review checklist.

🏛️

Round 4 — Advanced Security & Async Apex Scenarios

Q40–Q61 · Deeper sharing scenarios, async Apex edge cases, and production troubleshooting

Q040Round 4

How do you manage object-level and field-level security in real-time, and when would you use a Permission Set versus a Profile?

Profiles set the baseline access every user of that type gets; Permission Sets layer additional access on top for specific users or groups without needing a whole new Profile — use Permission Sets whenever the extra access applies to a subset of users within an existing Profile.

🔑 Key Points

The general best practice trend is toward minimal Profiles (baseline only) plus most actual permission-granting done through Permission Sets and Permission Set Groups, since it's far more flexible to assign/revoke than cloning Profiles. Permission Set Groups additionally let you bundle several related Permission Sets into one assignable unit, reducing the number of individual assignments an admin has to manage per user.

🌍 Example

Instead of cloning a Profile to give 5 users temporary edit access on a new object, a Permission Set is created and assigned to exactly those 5 users — revoking it later is a single click, versus untangling a cloned Profile that may have drifted from the original over time.

Q041Round 4

Scenario: You created a Permission Set giving Edit access on Case to a group of sales users, but that access shouldn't last forever — it needs to end after a period. How do you design this?

Use a Permission Set Group assignment with an expiration date set on the PermissionSetAssignment record itself, or build a scheduled Flow/Batch that queries for expired assignments and removes them automatically.

🔑 Key Points

Salesforce natively supports an expiration date field on individual Permission Set assignments — for a group of users this is often best handled via a small scheduled Apex or Flow that enforces the expiry consistently rather than relying on manual admin follow-up, which is exactly the kind of task that gets forgotten without automation.

🌍 Example

A quarter-end sales promotion grants temporary Case edit access to the sales team for 30 days via a scheduled expiration date on the assignment, so access silently and automatically reverts without anyone needing to remember to revoke it manually.

PermissionSetAssignment psa = new PermissionSetAssignment( AssigneeId = userId, PermissionSetId = psId, ExpirationDate = Date.today().addDays(30)); insert psa;

Q042Round 4

How do you share a Job__c record with a public Queue using Apex? Write a snippet.

Insert a record into the Job__Share object with the Queue's Id as the UserOrGroupId (Queues are a type of Group in Salesforce) and the desired access level.

🔑 Key Points

Because Queues are internally represented as a special kind of Group record, the same Apex-managed sharing pattern used for individual users or public groups applies unchanged — you just need the Queue's underlying Group Id, which differs from the Queue's own Id shown in Setup.

Job__Share js = new Job__Share( ParentId = jobRecord.Id, UserOrGroupId = queueId, // the Group Id representing the Queue AccessLevel = 'Edit', RowCause = Schema.Job__Share.RowCause.Manual ); insert js;

Q043Round 4

You want to query all Contacts and Leads in your org with a particular email — say manjunath@gmail.com. How would you do that in one go?

SOQL can't natively union two different sObject types in a single query — you either run two separate queries and merge the results in Apex, or use SOSL, which searches across multiple objects simultaneously in one call.

🔑 Key Points

SOSL is the right tool specifically when the search field is indexed for text search and you genuinely need results from multiple unrelated object types together — for anything needing precise filtering logic beyond a simple match, two separate SOQL queries are usually cleaner and more predictable.

List<List<SObject>> results = [FIND 'manjunath@gmail.com' IN EMAIL FIELDS RETURNING Lead(Id, Name), Contact(Id, Name)]; List<Lead> leads = (List<Lead>) results[0]; List<Contact> contacts = (List<Contact>) results[1];

Q044Round 4

Your org has a marketing and sales team both creating Leads/Contacts, and you're seeing lots of duplicate links getting created. What would you do to avoid this?

Configure standard Matching Rules and Duplicate Rules on Lead and Contact (block or warn on create/edit), and for the initial cleanup of existing duplicates, run a one-time dedup pass using Data.com/AppExchange dedup tools or a custom Batch Apex matching job.

🔑 Key Points

Matching Rules define *how* two records are considered a duplicate (fuzzy vs exact matching); Duplicate Rules define *what happens* when a match is found (block, alert, or allow with a warning) — both need to be configured together, and getting the matching algorithm too loose or too strict is the most common real-world tuning mistake.

🌍 Example

A marketing team's web-to-lead form and the sales team's manual Lead creation both feeding the same object get a shared Duplicate Rule set to "Block" on exact email match, eliminating the majority of duplicate creation at the point of entry rather than needing constant retroactive cleanup.

Q045Round 4

Define Matching Rules and Duplicate Rules and how they relate to each other.

A Matching Rule defines the criteria and algorithm (exact or fuzzy) used to identify potential duplicate records; a Duplicate Rule references one or more Matching Rules and defines the action to take (block, alert) when a match is found during create or edit.

🔑 Key Points

You can have multiple Matching Rules feeding into a single Duplicate Rule — for example, matching on Email OR on Phone+LastName combined — giving you flexible dedup logic without custom code. Standard Matching Rules ship pre-built for Account/Contact/Lead, but custom ones can be built for any object including custom objects.

Q046Round 4

What is the difference between the Time Component and Variant Component concept in LWC?

This is a niche/legacy Aura-era distinction rather than a core LWC concept — for the current LWC component model, decorators, and lifecycle hooks, see the full LWC Interview Questions guide.

Q047Round 4

Explain the different ways to handle asynchronous execution in Apex.

Future methods (simple, primitive params only, no chaining), Queueable Apex (chainable, accepts sObjects/complex types, trackable via Job Id), Batch Apex (processes up to 50 million records in scoped chunks), and Scheduled Apex (cron-based recurring execution) — each suited to a different volume/complexity profile.

🔑 Key Points

As a rule of thumb for a consulting recommendation: Queueable for anything needing chaining or complex parameters, Batch specifically for large-volume record processing, Scheduled for recurring jobs, and future methods mainly for simple legacy compatibility. Platform Events add a fifth option worth mentioning — for decoupled, event-driven communication rather than sequential processing.

🌍 Example

A nightly price recalculation across 2 million Product records uses Batch Apex specifically for its scoped-chunk processing; a one-off "send this single confirmation email after checkout" uses a simple future method since there's no chaining or complex parameter need.

Q048Round 4

You are required to communicate information to a third-party legacy system using an exposed endpoint. How would you accomplish this?

Expose an Apex REST service using @RestResource(urlMapping) with @HttpPost/@HttpGet methods, secure it via a Connected App with OAuth or a dedicated integration user, and have the legacy system call that endpoint with the appropriate authentication headers.

🔑 Key Points

Version the URL mapping explicitly (e.g. /legacyIntegration/v1/*) from day one — legacy systems are often slow to adapt to breaking API changes, and having a version segment baked in from the start avoids a painful retrofit later when the contract needs to evolve.

@RestResource(urlMapping='/legacyIntegration/*') global with sharing class LegacyIntegrationService { @HttpPost global static String receiveData(String payload) { // process payload, return response return 'OK'; } }

Q049Round 4

When would you use Queueable Apex, and how do you handle it in your test class when testing async operations like Queueable, @future, or callouts?

Use Queueable when you need chaining, complex parameter types, or trackable job status. In tests, tc-wrap the enqueue/callout logic between Test.startTest() and Test.stopTest() so the async work runs synchronously and can be asserted on immediately.

🔑 Key Points

For callouts specifically, you additionally need to implement HttpCalloutMock and register it via Test.setMock() before startTest(), since real HTTP callouts are never allowed inside a test context — this is a separate requirement from the startTest()/stopTest() wrapping and both are needed together for callout-based async tests.

Q050Round 4

Explain the difference between synchronous and asynchronous execution in Apex.

Synchronous code executes immediately in the current transaction and blocks until complete, sharing the same governor limits as the triggering action; asynchronous code is queued and executes in a separate transaction later, with its own fresh set of governor limits.

🔑 Key Points

This is exactly why long-running operations (large data processing, external callouts from a trigger) get pushed to async — synchronous transactions have much tighter limits since they're expected to complete within the user's page-load wait time, while async jobs have no such user-facing time pressure.

Q051Round 4

If asynchronous execution runs in a separate thread and you don't know exactly when the response arrives, how do you design your test class around that uncertainty?

You don't actually wait for real elapsed time in a test — Test.stopTest() forces all queued async work (future, Queueable, scheduled, batch) to execute synchronously and complete before the next line runs, regardless of what the "real" delay would have been in production.

🔑 Key Points

This is precisely why Test.startTest()/stopTest() exists: it collapses asynchronous, time-uncertain execution into a deterministic, immediately-assertable block for testing purposes, without your test ever needing to actually sleep or poll for completion.

Q052Round 4

You're calling a future method and need to write unit tests for it. How do you cover that async code?

Wrap the call to the future method between Test.startTest() and Test.stopTest() — the future method executes synchronously the moment stopTest() is reached, and your assertions afterward check its actual side effects.

Test.startTest(); MyClass.myFutureMethod(recordId); Test.stopTest(); // assertions here -- future method has already executed synchronously

Q053Round 4

One of your classes doesn't individually have 75% code coverage, but your org's average coverage overall is above 75%. Will your deployment work?

No — Salesforce requires overall org coverage to be at least 75% AND every individual Apex trigger to have some coverage; while there's no strict per-class 75% minimum enforced at deployment for classes specifically, in practice many orgs additionally enforce per-class minimums via CI policy even though Salesforce itself only strictly checks the aggregate plus trigger coverage.

🔑 Key Points

This is a frequently-misunderstood nuance — the platform's hard deployment gate is the 75% aggregate (plus every trigger having *some* coverage), but professional engagements almost always layer a stricter per-class policy (often 85-90%) on top via their CI pipeline specifically because relying only on the platform minimum lets individual classes go completely untested.

Q054Round 4

Explain DML Exceptions in detail, and what are Setup versus non-Setup objects?

Setup objects are those tied to org configuration and user management (User, Group, GroupMember, and similar); non-setup objects are regular business data records (Account, custom objects). Mixing DML on both types within a single transaction throws a MIXED_DML_OPERATION exception.

🔑 Key Points

The platform enforces this separation because Setup object changes can affect data visibility/security mid-transaction, which could create an inconsistent security state if mixed with regular business-object DML in the same atomic operation. This restriction most commonly bites developers in test classes, where creating a test User alongside test business data is a very natural thing to want to do together.

Q055Round 4

In your test class, you create a User (a Setup object) and, in the same method, an Opportunity — and you get blocked by a MixedDML exception. How do you solve this?

Wrap the Setup-object DML (User creation) in System.runAs(), which executes in a separate transaction context, isolating it from the non-setup DML that follows in the main test method.

🔑 Key Points

System.runAs() is specifically designed for exactly this test-context scenario — outside of tests, you'd solve mixed setup/non-setup DML by simply splitting them into genuinely separate transactions (e.g. two separate Apex invocations), since runAs() itself is only usable in test context.

System.runAs(new User(Id = UserInfo.getUserId())) { insert testUser; // Setup object DML isolated here } insert new Opportunity(Name='Test', StageName='Prospecting', CloseDate=Date.today());

Q056Round 4

You have a batch that runs nightly on Accounts and processes them. You need to count how many Accounts from the Energy industry have been processed so far — how would you do this across batch executions?

Implement Database.Stateful on the Batch class and maintain an Integer counter as an instance member — Database.Stateful preserves instance variable state across execute() invocations within the same job (normally each chunk runs in complete isolation).

🔑 Key Points

Without Database.Stateful, a Batch class's instance variables reset to their initial value on every single execute() call — the counter would always read as if only the current chunk had ever run. Database.Stateful does add a small performance cost since the instance state is serialized between chunks, so only apply it when you genuinely need cross-chunk state like this.

global class EnergyAccountBatch implements Database.Batchable<sObject>, Database.Stateful { global Integer processedCount = 0; global void execute(Database.BatchableContext bc, List<Account> scope) { for (Account a : scope) if (a.Industry == 'Energy') processedCount++; } }

Q057Round 4

A feature worked fine in every lower environment (Dev, QA, UAT), but in Production you're getting a "non-authorized endpoint" exception on go-live. What's the likely reason, and how do you fix it?

The Remote Site Setting or Named Credential for that endpoint was never actually created in Production — lower environments frequently have looser or pre-existing endpoint authorizations that simply don't carry over automatically with a metadata deployment in every org type.

🔑 Key Points

This is one of the most common "worked everywhere except Prod" bugs in Salesforce specifically because Remote Site Settings/Named Credentials are org-specific admin configuration, not something that migrates via a standard package deployment unless explicitly included — a strong go-live checklist should always list environment-specific config like this as an explicit verification step.

🌍 Example

A go-live checklist item catches this exact class of bug before it becomes a production incident: "confirm every Remote Site Setting/Named Credential referenced by deployed Apex actually exists in the target org" — a 5-minute check that prevents an embarrassing day-one outage.

Q058Round 4

How do you authorize an external endpoint in Salesforce generally, and how do you resolve an "Unauthorized endpoint" error in Production specifically?

Add the target URL under Setup → Remote Site Settings (or configure a Named Credential with the endpoint and auth details), then verify the specific error message's exact URL matches character-for-character what's whitelisted — trailing slashes and http vs https mismatches are common silent culprits.

🔑 Key Points

Even a single differing character (a trailing slash present in one but not the other, or http vs https) causes a silent mismatch that produces this exact error — always copy the URL directly from the actual exception message rather than retyping it from memory when troubleshooting.

Q059Round 4

The sales manager wants to see the average Amount from all Closed Won Opportunities. How would you achieve this — write the code.

Use an aggregate SOQL query with the AVG() function filtered to StageName = 'Closed Won'.

AggregateResult ar = [SELECT AVG(Amount) avgAmt FROM Opportunity WHERE StageName = 'Closed Won']; Decimal averageAmount = (Decimal) ar.get('avgAmt');

Q060Round 4

You need to ensure Shipping Address is never left blank when creating or updating an Account, and every Account must have Shipping Address filled. Write a Trigger for this.

On before insert and before update, check if the ShippingStreet/ShippingCity fields are blank and call addError() to block the save — though in practice a Validation Rule is the simpler declarative tool for this exact requirement.

🔑 Key Points

This is a good moment in an interview to mention that a Validation Rule (not(ISBLANK(ShippingStreet))) achieves the identical result with zero code — showing judgment about when NOT to write Apex is itself a strong consulting signal, since a maintainable declarative solution is almost always preferable to unnecessary custom code.

trigger AccountShippingCheck on Account (before insert, before update) { for (Account acc : Trigger.new) { if (String.isBlank(acc.ShippingStreet)) { acc.ShippingStreet.addError('Shipping Address is required.'); } } }

Q061Round 4

Every time an Account's Active field is changed to false, you need to mask the email addresses of all its related Contacts. Write the code and explain.

On Account after update, detect where Active__c flipped from true to false by comparing Trigger.new against Trigger.oldMap, then bulk-query and update the related Contacts' Email fields to a masked placeholder value.

🔑 Key Points

Always compare against oldMap to catch the specific true-to-false transition — blindly masking emails on every update (even ones unrelated to the Active field) would silently destroy real contact data. Consider also whether this masking should be reversible — if Active__c is ever flipped back to true, does the business expect original emails restored, or is the masking meant to be permanent?

🌍 Example

A B2B client deactivates a churned customer Account, and the automated email-masking trigger scrubs the related Contacts' emails as part of a data-retention compliance policy, without a human needing to manually process each Contact.

trigger MaskContactEmails on Account (after update) { Set<Id> deactivatedIds = new Set<Id>(); for (Account acc : Trigger.new) { if (acc.Active__c == false && Trigger.oldMap.get(acc.Id).Active__c == true) { deactivatedIds.add(acc.Id); } } if (deactivatedIds.isEmpty()) return; List<Contact> toMask = [SELECT Id, Email FROM Contact WHERE AccountId IN :deactivatedIds]; for (Contact c : toMask) c.Email = 'masked_' + c.Id + '@redacted.invalid'; update toMask; }

🤝

Consulting Round — Client-Facing & Scoping Questions

Q62–Q81 · Client communication, scoping, data migration, and business-alignment questions

Q062Consulting Round

What advice would you give a customer with little to no Salesforce experience who is planning to self-implement?

Explain the two-fold risk plainly: without knowing how the platform's interlinking pieces should be configured, something will likely be set up incorrectly and need costly rework later — and a consultancy brings not just platform knowledge but years of pattern-matching against similar businesses' processes.

🔑 Key Points

Frame this as a partnership pitch, not a scare tactic — mention that requirements gathering, training, and adoption planning are just as critical to project success as the technical configuration itself, and self-implementation almost always underinvests in exactly these three non-technical pillars.

🌍 Example

A small business self-implementing Sales Cloud often gets the object model roughly right but skips requirements gathering entirely — six months later they're paying a consultancy to unwind an OWD/sharing model that was never actually designed against real access requirements, only guessed at.

Q063Consulting Round

What are your top three tips to improve user adoption on a Salesforce project?

Ongoing (not one-off) training across multiple formats, a clear post-launch support plan (power users, admin, or consultancy retainer), and involving end users early in the project so they feel ownership over the system being built.

🔑 Key Points

The fourth often-missed tip: keep iterating post-launch based on real user feedback — adoption isn't a go-live milestone, it's an ongoing relationship with the user base, and a system that stops evolving after launch quietly loses adoption over the following months.

🌍 Example

A sales team's Salesforce adoption stalls three months post-launch not because of a technical flaw, but because no one collected feedback after go-live — a monthly "what's frustrating you" check-in with power users would have caught and fixed small friction points before they compounded into disengagement.

Q064Consulting Round

What's your best-practice advice for maintaining clean data in Salesforce?

Prevent bad data at the point of entry using Validation Rules, required fields, and picklists over free text; catch duplicates proactively with Matching/Duplicate Rules; and for existing dirty data, run a structured retrospective cleanup (often via an AppExchange dedup tool) rather than ad hoc manual fixes.

🔑 Key Points

Prevention is always cheaper than cleanup — a consultant's first data-quality conversation with a client should be about the entry points, not the existing mess, since every dollar spent on prevention avoids a much larger future cleanup cost.

🌍 Example

A lead-gen form using a free-text "State" field instead of a picklist generates dozens of inconsistent spellings ("CA", "Calif", "California") that break every report filtering by state — switching to a picklist retroactively is trivial, but cleaning six months of accumulated free-text variants is not.

Q065Consulting Round

Explain the core differences between Sales Cloud and Service Cloud.

Sales Cloud is built around the sales cycle — lead management, Opportunity tracking, forecasting, and quoting; Service Cloud sits on the same core CRM but is built for customer support — Case management, Entitlements, Knowledge base, and Email-to-Case.

🔑 Key Points

Both share the same underlying Account/Contact data model, which is exactly why many orgs run both clouds together on a single instance without any real architectural conflict — a client rarely needs to choose one exclusively, and most mid-size-and-up businesses eventually run both.

Q066Consulting Round

What are the fundamental skill differences between a Salesforce Admin and a Salesforce Technical Consultant?

An Admin's core responsibility is maintaining and configuring an existing system for known users; a Consultant is brought in specifically to solve complex, often cross-cloud business problems, requiring stronger business analysis and solution-design skills on top of platform knowledge.

🔑 Key Points

There's significant overlap, but the consultant role leans much more heavily on translating ambiguous business requirements into a concrete technical solution — that translation skill is the real differentiator interviewers probe for, more than raw platform feature knowledge, which both roles generally share.

Q067Consulting Round

What are the benefits of the Salesforce AppExchange in a client engagement?

It provides pre-built, vetted solutions (free or paid) that extend platform functionality without custom development — from simple utilities like record cloning to complete vertical solutions like FinancialForce for accounting.

🔑 Key Points

As a consultant, recommending a proven AppExchange package over custom-building the same functionality from scratch is often the more cost-effective and lower-risk choice — know when NOT to build custom, since a package with an established user base has already worked out edge cases a first custom build would need to rediscover independently.

🌍 Example

A client needing double-entry accounting integrated with Salesforce is far better served by an established AppExchange package like FinancialForce than a custom-built solution attempting to reinvent core accounting logic that's already been solved and battle-tested by thousands of other orgs.

Q068Consulting Round

How would you explain what Salesforce is to a completely non-technical client who doesn't even know what a CRM is?

Frame it around something universal: every business, no matter how small, tracks customer relationships somehow — a market stall owner's notebook and an enterprise's Salesforce org are solving the exact same underlying problem, just at different scale.

🔑 Key Points

Avoid Salesforce jargon entirely in this explanation — the goal is analogy, not accuracy to platform terminology, since the audience has zero context for terms like Lead or Opportunity yet, and introducing that vocabulary too early usually causes them to disengage from the conversation.

Q069Consulting Round

What are your tips for communicating technical concepts to non-technical stakeholders?

Talk about outcomes and processes, not Salesforce terminology — say "automation" instead of "Flow," focus on the people/process impact rather than the technical mechanism, and use concrete examples rather than abstract descriptions.

🔑 Key Points

Never make a non-technical stakeholder feel less intelligent for not knowing platform terms — that erosion of trust is far more damaging to a project's success than any technical misstep, since stakeholders who feel talked down to stop engaging honestly in requirements conversations.

🌍 Example

Instead of saying "we'll build a Record-Triggered Flow to update the Opportunity Stage," a consultant says "the system will automatically move the deal forward once the contract is signed" — same technical work, dramatically more accessible framing.

Q070Consulting Round

How would you support a client who is very resistant to change during a Salesforce implementation?

Involve resistant stakeholders early so they feel ownership rather than having change imposed on them, focus conversations on the tangible time-saving benefit to *them* specifically rather than the technical solution itself, and show empathy for the discomfort of an external party changing familiar workflows.

🔑 Key Points

"If it ain't broke, don't fix it" resistance is almost always really about fear of disruption, not disagreement with the logic — address the emotional resistance directly, not just the rational argument, since a purely logical counter-argument rarely moves someone whose actual objection is emotional.

Q071Consulting Round

List three critical success factors for a new Salesforce implementation.

User and management buy-in from day one, a real training plan (not a one-off session), and a properly planned data migration — neglecting any one of these commonly tanks adoption even when the technical build itself is flawless.

🔑 Key Points

Reporting & Dashboards deserve a fourth mention — without visible insights into what's happening in the org, neither users nor management have a reason to keep engaging with the system post-launch, since the value of the CRM only becomes tangible once it's generating usable insight back to the business.

Q072Consulting Round

What are common causes of project scope creep, and how do you reduce the risk of it?

Poorly defined scope of work with too much "wiggle room" in the original proposal, and weak project management that lets ownership of in-scope/out-of-scope decisions become ambiguous — both fixed by writing explicit in-scope AND out-of-scope items into the SOW upfront.

🔑 Key Points

The longer a project runs, the more opportunity for scope creep to accumulate — tight project management with clear timelines is itself a scope-creep prevention mechanism, not just a delivery mechanism, since a well-managed short project simply has less time window for creep to accumulate in.

Q073Consulting Round

Describe a use case for enabling the Person Accounts feature.

Person Accounts merge the Account and Contact objects into a single record, used when a business sells to individual consumers (B2C) rather than organizations — Salesforce's default Account/Contact split assumes a B2B relationship structure otherwise.

🔑 Key Points

This is a genuinely irreversible, org-wide decision once enabled — always flag that weight explicitly to a client considering it, since undoing it later essentially requires a full data migration and rebuild of every automation touching Account or Contact.

🌍 Example

A telecom company selling directly to individual consumers enables Person Accounts specifically because a standalone Account with no natural Contact underneath it (an individual customer isn't "an organization with employees") would otherwise force an awkward, artificial data model.

Q074Consulting Round

Scenario: An Account object has fields both a customer support team and a sales team use, but management doesn't want the support team to see a commission field on the same records. What solution would you propose?

Field-Level Security (FLS) on the Profile/Permission Set is the definitive fix — it removes the field's visibility platform-wide, including reports; a separate Page Layout alone only hides it from the record detail page, not from reports or list views.

🔑 Key Points

This is a classic "page layout vs FLS" trap question — page layout changes are cosmetic per-view, while FLS is the actual security enforcement mechanism that also protects the field in reports, APIs, and exports. A candidate who answers only "use a different page layout" hasn't actually solved the stated requirement.

🌍 Example

A support agent running an Account export or building a custom report would still see the commission field's raw value if only the page layout was changed — only FLS closes that gap consistently across every access path, not just the record detail page the agent normally views.

Q075Consulting Round

What is the difference between a Role and a Profile in Salesforce?

A Profile is mandatory for every user and controls object/field-level CRUD permissions and system permissions; a Role is optional and controls record-level visibility through the role hierarchy, granting access to records owned by subordinates.

🔑 Key Points

A user can have no Role at all and still function fully — Roles only matter once you need hierarchy-based record visibility, whereas every single user must have exactly one Profile. This distinction is a very common early trip-up for developers coming from a purely coding background with less admin exposure.

Q076Consulting Round

What are the main limitations of Salesforce Professional Edition compared to Enterprise Edition, and why does this matter for a consultant?

Professional Edition restricts or removes Apex, has limited API access (meaning most external integrations are impossible), and caps automation and sandbox availability — meaning a scope you'd casually recommend on Enterprise Edition may simply not be buildable at all on Professional.

🔑 Key Points

Always confirm the client's actual Salesforce edition early in a scoping conversation — recommending an Apex-based solution to a Professional Edition client is a scoping failure that surfaces painfully late otherwise, sometimes not until development has already begun.

🌍 Example

A consultant scopes a custom REST integration for a client, only to discover mid-project the client is on Professional Edition with no API access — a scoping conversation five minutes into discovery would have caught this before any design work was wasted.

Q077Consulting Round

What are three metrics or reports every Sales Manager should have set up in their org?

Lead/Opportunity win-loss ratio (with loss reasons captured), a last-activity report per Account (especially top accounts), and pipeline-by-stage to spot where deals are stalling.

🔑 Key Points

Capturing the *reason* behind lost deals, not just the loss itself, is what turns a report into an actionable business case — e.g. justifying a product feature request to leadership with real lost-revenue numbers tied to a specific, recurring loss reason.

Q078Consulting Round

A client has used 121% of their Salesforce data storage limit and asks what to do. What do you suggest?

Check the Company Information page to identify exactly which object/component is consuming the most storage (often one specific object or a legacy AppExchange app), review whether that data can be archived or purged, and treat purchasing additional storage as the last resort, not the first move.

🔑 Key Points

Storage overages are almost always concentrated in one or two objects — Attachments/Files and a high-volume custom object are the most common culprits worth checking first before recommending a costly storage add-on.

🌍 Example

A client's storage overage traces back almost entirely to five years of accumulated Task/Event Activity History records that were never archived — moving that historical data to Big Objects resolves the overage without buying a single extra megabyte of storage.

Q079Consulting Round

A client manually creates quotes in Word using a separate Excel sheet for cost calculations, with 5 reps doing up to 10 quotes a day on Salesforce Sales Cloud. What would you recommend to automate this?

Recommend Salesforce's native Quoting engine first (generates a PDF quote with attached Products, tied to Opportunity/Pricebook), and only escalate to a full CPQ solution if the pricing/discounting logic is complex enough to genuinely need it.

🔑 Key Points

This is a strong test of scoping discipline — the temptation is to jump straight to recommending CPQ, but native Quotes may fully solve a relatively simple use case at a fraction of the cost and implementation time, and over-scoping to CPQ when it's not needed is a common consulting mistake that inflates project cost unnecessarily.

Q080Consulting Round

How do you approach a large-scale data migration project, such as merging data from an acquired company with poor data quality?

Phase the migration (master data like Accounts/Contacts first, transactional data second), establish an External ID strategy upfront since primary keys from legacy systems are often unreliable, and build custom deduplication logic specifically tuned to the known data quality issues before the actual load.

🔑 Key Points

A phased approach isn't just risk management — mapping master data first means transactional records in the second phase can reliably reference already-migrated, deduplicated parent records instead of creating orphans, which is a much harder problem to fix retroactively once the transactional data is already loaded.

Q081Consulting Round

How does Salesforce Financial Services Cloud typically integrate with external systems, and what security considerations come with it?

FSC integrates via REST/SOAP APIs and middleware for real-time data sync with external financial/banking systems; because of the regulated industry, field-level encryption, detailed audit trails, and compliance with standards like GDPR/FINRA are non-negotiable parts of the design, not optional add-ons.

🔑 Key Points

Given the regulatory weight in Financial Services specifically, a consultant should proactively raise compliance requirements during discovery rather than waiting for the client's legal/compliance team to flag it later in the project, since retrofitting encryption and audit trail requirements after a design is already built is significantly more expensive than designing for them from day one.

🧠

Scenario Round — Real-World Consultant Scenarios

Q82–Q96 · Architecture and client-management scenarios worth rehearsing before any consultant interview

Q082Scenario Round

A client's Salesforce org has grown to 40+ Apex triggers built by three different past vendors, with no consistent framework. How do you approach stabilizing this before adding any new functionality?

Run an org health audit first (Salesforce Optimizer plus manual trigger review) to map what exists, consolidate to one trigger-per-object routed through a shared handler framework incrementally, and resist the urge to "big bang" rewrite everything at once.

🔑 Key Points

A phased consolidation — starting with the objects causing the most active bugs or governor limit issues — de-risks the stabilization work far more than attempting to rebuild the entire automation layer in one release, and gives the client visible wins early rather than a long silent rewrite period with no observable progress.

🌍 Example

An org with 5 separate triggers on the Opportunity object alone, some duplicating logic, gets consolidated into one trigger routed through a handler class first — chosen as the starting point specifically because it's also the object generating the most support tickets that month.

Q083Scenario Round

During discovery, a client insists they need a fully custom-built quoting engine, but their actual requirements sound like standard Salesforce CPQ would cover 90% of it. How do you handle this conversation?

Map their stated requirements explicitly against CPQ's out-of-the-box capabilities in a working session, show them concretely where the 10% gap actually is, and let the cost/timeline difference between "customize the 10%" versus "build 100% custom" make the case rather than just asserting it.

🔑 Key Points

Clients often ask for custom-build because they don't know a standard feature already solves their problem — the consultant's job is translation, not just execution of whatever's initially requested, and a side-by-side requirements mapping is far more persuasive than a verbal assertion that "CPQ can do that."

Q084Scenario Round

You're proposing a solution that requires a platform license upgrade the client wasn't expecting, adding significant cost. How do you present this without losing the deal?

Present it as a cost-of-doing-nothing comparison: what workaround or limitation they'd be stuck with on their current license versus the ROI the upgrade unlocks, backed by a concrete example from their own requirements rather than an abstract feature list.

🔑 Key Points

Never lead with the price increase in isolation — lead with the specific business capability it unlocks, then let the cost follow as the logical next question rather than the opening statement, since starting with a number invites an immediate defensive reaction before the value has even been established.

Q085Scenario Round

Midway through a project, the client's internal admin who was your main point of contact leaves the company. How do you keep the project on track?

Immediately document and hand off all decisions, open questions, and context that lived only in that person's head, escalate to identify a new internal point of contact quickly, and build extra buffer into upcoming milestones that depended on that person's institutional knowledge.

🔑 Key Points

This is exactly the scenario good project documentation habits (decision logs, requirement traceability) protect against — the earlier in the project those habits started, the less painful this transition is, since a project that's been logging decisions in writing all along loses far less institutional knowledge than one relying on tribal memory.

Q086Scenario Round

A client wants real-time inventory sync between Salesforce and an on-premise ERP system that has no modern REST API, only a legacy SOAP interface with unreliable uptime. How would you architect this?

Introduce a middleware/integration layer (MuleSoft or similar) as a buffer between Salesforce and the unreliable legacy system, with a message queue that retries failed sync attempts, so a temporary ERP outage doesn't directly break the user-facing Salesforce experience.

🔑 Key Points

Never architect a direct, synchronous dependency on a system you know is unreliable — the middleware queue layer is specifically what decouples Salesforce's uptime from the legacy system's uptime, meaning a 2-hour ERP outage becomes a delayed sync rather than a broken one.

Q087Scenario Round

The client's Sales team and Support team disagree on what "Customer" means for reporting purposes — Sales wants it based on Closed Won Opportunities, Support wants it based on an active support contract. How do you resolve this as a consultant?

This isn't a technical problem first — facilitate a definitions-alignment workshop with both stakeholder groups to agree on a single source of truth (or explicitly two distinct fields with clear names), since building either version without agreement just moves the argument into production.

🔑 Key Points

A consultant's highest-value contribution here is often not code at all — it's forcing the business alignment conversation that technical teams frequently skip past straight into implementation, and building the "wrong" definition first only means redoing the work later once the disagreement inevitably surfaces in a report review.

Q088Scenario Round

A client's org has Apex CPU timeout errors happening intermittently, only during their month-end close process. How do you investigate this?

Pull debug logs specifically from the month-end window, look for nested loops or unbounded recursive triggers that only hit volume thresholds during that high-activity period, and check whether a scheduled batch job's timing overlaps with peak month-end user activity, compounding load.

🔑 Key Points

Intermittent, volume-correlated CPU timeouts almost always point to an O(n²) pattern that's fine at normal daily volume but breaks down exactly when record counts spike — month-end close is a classic volume-spike trigger, and the fix is usually replacing a nested-loop lookup with a Map-based one rather than any exotic solution.

Q089Scenario Round

How do you handle a situation where the client's chosen AppExchange package genuinely conflicts with a core requirement you're building custom Apex for?

Investigate whether the package exposes an Apex API or extension points you can build against instead of working around it, and if a genuine conflict exists, document the specific limitation clearly for the client with the tradeoff options (drop the package, replace it, or accept the workaround) rather than silently picking one.

🔑 Key Points

Silently working around a paid AppExchange package's limitation without flagging it to the client risks a fragile solution the client doesn't even know they're depending on — transparency here protects both the project and your credibility, and lets the client make an informed call on whether the package is even still worth its license cost.

Q090Scenario Round

You're asked to estimate a complex multi-cloud (Sales Cloud + Service Cloud + Experience Cloud) implementation for a Statement of Work. What's your approach to estimation?

Break the scope into discrete, independently estimable epics per cloud, apply a consistent estimation technique (t-shirt sizing or story points) validated against past similar engagements, and explicitly call out assumptions and out-of-scope items in the SOW to protect against scope creep later.

🔑 Key Points

The biggest estimation risk in multi-cloud engagements is underestimating the *integration* work between clouds — each cloud's estimate in isolation is usually more accurate than people expect, but the glue connecting them is where hours quietly disappear, so a dedicated integration-effort line item in the estimate (not folded silently into each cloud's estimate) is worth calling out explicitly.

Q091Scenario Round

A long-time client asks you to bypass your own recommended validation rule "just this once" to push through a bad data record for an urgent deal. How do you handle it?

Understand the business urgency, but propose a safer alternative — a temporary, logged, and reversible exception (like a time-boxed Custom Permission bypass) rather than disabling the validation rule outright, which risks letting more bad data through unnoticed afterward.

🔑 Key Points

The goal is solving the client's immediate urgency without quietly eroding the data-quality guardrails you were hired to establish — a logged, reversible exception achieves both, and the audit trail it leaves behind also protects you if the bypassed record later causes a downstream problem someone needs to trace back.

Q092Scenario Round

How would you evaluate whether a client's requirement should be solved with a Flow versus Apex versus a third-party AppExchange tool?

Weigh maintainability (who on the client's team can support it after you leave — an admin can maintain a Flow but not Apex), complexity of the business logic (deeply nested conditional logic often becomes unreadable in Flow but is clean in Apex), and whether a vetted AppExchange package already solves 80%+ of the need at lower total cost.

🔑 Key Points

The maintainability question matters more in consulting than in-house development — you're often handing the solution off to a client admin team, so choosing Flow over Apex purely for their long-term supportability is a legitimate, even preferred, technical decision, not a compromise on quality.

Q093Scenario Round

A client's previous consultancy left behind a Salesforce org with almost no documentation. How do you approach ramping up on it before proposing any new work?

Run Salesforce Optimizer for a baseline health snapshot, review Setup Audit Trail history for a sense of what's changed recently and by whom, and interview key business users about their actual day-to-day workflows — since the org's real usage patterns often diverge significantly from what the metadata alone suggests.

🔑 Key Points

Metadata tells you what was built; talking to actual users tells you what's actually being used, ignored, or worked around — both are necessary before proposing changes to an undocumented org, since a feature that looks important in the metadata might be something users abandoned using months ago in favor of a workaround.

Q094Scenario Round

How do you handle disagreement with a client stakeholder about the technical feasibility of a request they insist is "simple"?

Avoid arguing feasibility in the abstract — build or describe a quick proof-of-concept or spike showing the actual complexity (or confirming it really is simple), letting concrete evidence settle the disagreement rather than a battle of assertions.

🔑 Key Points

Stakeholders calling something "simple" are almost always comparing it to a similar-looking feature they've seen elsewhere, without visibility into the specific platform or data constraints that make it harder in this particular org — a quick spike closes that visibility gap fast and turns a subjective disagreement into an objective, shared understanding.

Q095Scenario Round

Your client wants a phased go-live (Sales Cloud first, Service Cloud three months later) but a core data model decision now will be hard to change once Sales Cloud is live. How do you approach this decision point?

Explicitly design the Phase 1 data model with the known Phase 2 requirements in mind — even if Service Cloud objects aren't built yet, the underlying Account/Contact/Case relationship structure should already accommodate them, since retrofitting a live production data model is far more disruptive than over-planning upfront.

🔑 Key Points

This is where a consultant's value is architectural foresight, not just delivering what's asked for in Phase 1 — a technically "complete" Phase 1 that ignores Phase 2 can become an expensive redesign three months later, undermining the entire value of having phased the rollout in the first place.

Q096Scenario Round

A client asks you to recommend whether they should build a custom Lightning Web Component or just use a standard Lightning App Builder page with out-of-the-box components. How do you decide?

Default to standard components and App Builder configuration first — reach for custom LWC only when the requirement genuinely needs interactivity, data aggregation, or a UX pattern the standard component library can't express declaratively.

🔑 Key Points

This mirrors the Flow-vs-Apex tradeoff: maintainability by the client's own admin team should weigh heavily in the decision. See the LWC Interview Questions guide for the deeper technical tradeoffs once custom LWC is the right call.

📚 More free Salesforce prep from SF Interview Pro

🏠 Home — All Free Resources 🧩 LWC Interview Questions 🏢 Company-Wise Interview Questions 🎯 Practice Zone — 2,244 MCQs ⚙️ Apex Triggers Interview Questions

SF Interview Pro is a free, full-stack Salesforce career platform — no signup, no paywall. Visit sfinterviewpro.com →

Test yourself on this topic

2,244 practice MCQs across 27 quizzes — 5 quizzes free, no signup

Open Practice Zone →

Written by

Rajnish Kumar

Salesforce Developer · Apex, LWC, Data Cloud & AI · Building SF Interview Pro

Connect on LinkedIn ↗

Practice with real people

Join the free Mock Interview Community — practice with peers, get honest feedback, and walk into your real interview confident.

Join the Community ↗