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:

1. Create component
2. Add target in meta file
3. Deploy
4. 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.”