Top 25 Salesforce Interview Questions for Deloitte (With Real Answers)
Introduction
If you are preparing for a Salesforce interview at Deloitte, one thing you should know is this — they don’t just ask theory.
They focus a lot on:
- real-time scenarios
- how you think
- how you write code
- and how you design solutions
In this blog, I am not just listing questions. I am explaining them the way they are expected in an actual interview.
What kind of questions does Deloitte ask?
From experience, Deloitte interviews usually include:
- Apex and Trigger questions
- LWC concepts
- Flow vs Trigger decisions
- Scenario-based questions
- Performance and best practices
They are more interested in how you explain rather than just giving a definition.
Check Full Youtube video on Salesforce Interview Questions for Deloitte
Apex and Trigger Questions (Salesforce Interview Questions for Deloitte)
What are wrapper classes in Salesforce?
In simple words, wrapper classes are used when you want to combine data from multiple objects and send it together.
For example, in a real project, you might need to show:
- Account details
- and its related Contacts
in one screen.
In that case, you create a wrapper class and store both together.
public class AccountWrapper {
public Account acc;
public List<Contact> contacts;
}
This is commonly used in LWC and Visualforce.
What does bulkification mean?
Bulkification means writing your code in such a way that it can handle multiple records at once.
In real projects, Salesforce never processes just one record. It can process 100, 200, or even more.
So if your code works only for one record, it will fail.
A simple mistake many beginners make is writing SOQL inside a loop.
That will hit governor limits very quickly.
So always:
- use collections
- write SOQL outside loops
What is the difference between with sharing and without sharing?
This is a very common question.
- with sharing → follows user permissions
- without sharing → ignores permissions
In most cases, you should use with sharing, because security is important.
Only use without sharing when you really need system-level access.
What are governor limits?
Salesforce is a multi-tenant platform. That means many users share the same resources.
Because of that, Salesforce puts limits on how much you can use.
For example:
- 100 SOQL queries
- 150 DML operations
If you cross these limits, your code will fail.
That’s why writing optimized code is very important.
Write a trigger to count contacts on an account
This is a very common real-time question.
The requirement is simple:
Whenever a contact is added or removed, update the count on Account.
Here is a basic version:
trigger ContactCount on Contact (after insert, after delete) { Set<Id> accIds = new Set<Id>(); if(Trigger.isInsert){
for(Contact c : Trigger.new){
if(c.AccountId != null){
accIds.add(c.AccountId);
}
}
} if(Trigger.isDelete){
for(Contact c : Trigger.old){
if(c.AccountId != null){
accIds.add(c.AccountId);
}
}
} List<Account> accList = new List<Account>(); for(AggregateResult ar : [
SELECT AccountId, COUNT(Id) cnt
FROM Contact
WHERE AccountId IN :accIds
GROUP BY AccountId
]){
accList.add(new Account(
Id = (Id)ar.get('AccountId'),
Contact_Count__c = (Integer)ar.get('cnt')
));
} update accList;
}
In interviews, they are not expecting perfect syntax.
They want to see your approach and logic.
SOQL Questions (Salesforce Interview Questions for Deloitte)
Write a query to get accounts without contacts
This is a classic question.
SELECT Id, Name
FROM Account
WHERE Id NOT IN (SELECT AccountId FROM Contact)
They may also ask you to optimize it or explain how it works.
What is the difference between SOQL and SOSL?
Simple explanation:
- SOQL → used when you know what you are looking for
- SOSL → used when you are searching like a keyword search
Example:
If you want all accounts with a specific name → SOQL
If you want to search a word across multiple objects → SOSL
Flow and Automation Questions (Salesforce Interview Questions for Deloitte)
What are different types of flows?
There are multiple types, but mainly you should remember:
- Record-triggered flow
- Screen flow
- Scheduled flow
- Autolaunched flow
In real projects, record-triggered flows are used the most.
Can flow be used instead of trigger?
Yes, in many cases.
For example, counting contacts on account can be done using flow:
- trigger flow when contact is created
- get related contacts
- store count
But there is a problem.
When data volume is high, flow may not perform well.
So:
- simple logic → flow
- complex or high data → trigger
When should you use flow vs trigger?
This is a decision-making question.
Use flow when:
- logic is simple
- no heavy processing
Use trigger when:
- logic is complex
- performance matters
Lightning Web Components (LWC)
What are decorators in LWC?
Decorators are used to control how variables behave.
Main ones:
- @api → used to expose property
- @track → makes variable reactive
- @wire → used to fetch data
Difference between @wire and imperative calls
This is very important.
- @wire → automatic, reactive
- imperative → manual call
Use @wire when you want automatic updates.
Use imperative when you need control.
How to use LWC in Experience Builder?
Steps are simple:
- Create component
- Add target in meta file
- Deploy
- Use in Experience Builder
Scenario-Based Questions
How to convert lookup to master-detail?
You cannot just change it directly.
You need to check:
- no null values
- all child records must have parent
- no existing conflicts
Also remember:
- ownership changes
- sharing is controlled by parent
Best practices for profiles
This is more of an admin question.
Instead of creating too many profiles:
- use permission sets
- keep profiles minimal
How to call flow from Apex or LWC?
From Apex:
Flow.Interview flow = new Flow.Interview.MyFlow(params);
flow.start();
From LWC:
Use standard flow component.
Performance and Best Practices
How to optimize Apex performance?
In real projects, performance matters a lot.
Some simple rules:
- avoid SOQL in loops
- use maps and sets
- reduce DML operations
- use indexing where needed
What is bulkification in Salesforce? Explain with example
Bulkification means writing your Apex code in such a way that it can handle multiple records at the same time, instead of working on just one record.
In Salesforce, operations like triggers are not executed for a single record only. They can run for a batch of records (up to 200 records at once). So if your code is written only for one record, it may fail when multiple records are processed.
That’s why bulkification is very important.
Why is bulkification needed?
Salesforce has something called governor limits. For example:
- You can only run 100 SOQL queries in one transaction
- You can only perform 150 DML operations
If your code runs a query inside a loop, it may quickly hit these limits when multiple records are processed.
Example of non-bulkified code (bad practice)
for(Contact con : Trigger.new){
Account acc = [SELECT Id, Name FROM Account WHERE Id = :con.AccountId];
}
Problem:
- This query runs for every record
- If 200 records are processed → 200 queries → limit exceeded
Example of bulkified code (good practice)
Set<Id> accIds = new Set<Id>();for(Contact con : Trigger.new){
if(con.AccountId != null){
accIds.add(con.AccountId);
}
}Map<Id, Account> accMap = new Map<Id, Account>(
[SELECT Id, Name FROM Account WHERE Id IN :accIds]
);
Why this is correct:
- Only one SOQL query is used
- Works for multiple records
- Avoids governor limits
Real-time understanding of Bulkification
Let’s say:
- 200 contacts are inserted at once
If your code is not bulkified → it will fail
If your code is bulkified → it will handle all 200 records smoothly
Key points to mention in interview about the bulkification
- Always avoid SOQL and DML inside loops
- Use collections like List, Set, Map
- Write code assuming multiple records will be processed
- Bulkification improves performance and scalability
What are types of Asynchronous Apex in Salesforce?
Asynchronous Apex is used when you want to run processes in the background, instead of running them immediately.
This helps in:
- improving performance
- handling large data
- avoiding limits
Types of Asynchronous Apex
There are mainly four types:
1. Future Method
Future methods are used to run code asynchronously in the background.
When to use:
- Callouts to external systems
- Simple background processing
Example:
@future
public static void updateAccount(){
// logic here
}
Key points:
- Runs in background
- Cannot return values
- Cannot accept complex objects (only primitives or collections)
2. Queueable Apex
Queueable Apex is an improved version of future methods.
When to use:
- When you need better control
- When you want to chain jobs
- When you need to pass complex objects
Example:
public class MyQueueable implements Queueable {
public void execute(QueueableContext context){
// logic here
}
}
To call:
System.enqueueJob(new MyQueueable());
Key points:
- Supports chaining
- Can pass complex data
- More flexible than future
3. Batch Apex
Batch Apex is used to process large volumes of data (thousands or millions of records).
When to use:
- Data migration
- Data cleanup
- Scheduled large processing
Example:
public class MyBatch implements Database.Batchable<sObject> { public Database.QueryLocator start(Database.BatchableContext bc){
return Database.getQueryLocator('SELECT Id FROM Account');
} public void execute(Database.BatchableContext bc, List<Account> scope){
// logic here
} public void finish(Database.BatchableContext bc){
// post processing
}
}
Key points:
- Processes data in chunks (default 200 records)
- Helps avoid governor limits
- Can handle huge data
4. Scheduled Apex
Scheduled Apex is used to run jobs at a specific time.
When to use:
- Daily jobs
- Weekly reports
- Night batch processing
Example:
public class MyScheduler implements Schedulable {
public void execute(SchedulableContext sc){
// logic here
}
}
To schedule:
System.schedule('My Job', '0 0 12 * * ?', new MyScheduler());
Key points:
- Runs at a scheduled time
- Can be used with Batch Apex
Simple comparison (very useful in interview)
| Type | Use Case | Key Feature |
|---|---|---|
| Future | Simple async tasks | Easy to use |
| Queueable | Advanced async | Supports chaining |
| Batch | Large data processing | Handles millions of records |
| Scheduled | Time-based jobs | Runs on schedule |
How to explain in interview (simple line)
You can say:
“Asynchronous Apex is used to run processes in the background. Future is for simple tasks, Queueable gives more control, Batch is used for large data, and Scheduled is used for time-based execution.”
