Deloitte Interview Questions 2026 (with Answers for Freshers)

Last Updated: March 2026

About Deloitte

Deloitte is one of the 'Big Four' accounting organizations and the largest professional services network in the world by revenue and number of professionals. With over 415,000 employees globally, Deloitte provides audit, consulting, financial advisory, risk advisory, tax, and legal services. Known for its "Purpose-led, client-centric" approach, Deloitte helps organizations solve complex business challenges across industries. The company emphasizes innovation through Deloitte Digital, AI and analytics capabilities, and a strong commitment to diversity, inclusion, and social impact.

Deloitte Selection Process Overview

Round	Description	Duration	Key Focus Areas
Round 1: Online Assessment	Aptitude + Logical + Verbal + Game-Based	90-120 mins	Numerical, Logical, English, Cognitive Games
Round 2: Group Discussion	Topic-based discussion	15-20 mins	Communication, Leadership, Teamwork
Round 3: Versant Test	Spoken English assessment	20 mins	Pronunciation, Fluency, Comprehension
Round 4: Technical Interview	Technical + Case discussion	30-45 mins	Aptitude, Basic Programming, Case Studies
Round 5: HR Interview	Final screening	15-25 mins	Behavioral, Culture fit, Expectations

HR Interview Questions with Answers

Q1: Why Deloitte?

Q2: What do you know about Deloitte's service lines?

Audit & Assurance: Provides independent audit services, helping organizations enhance trust and confidence in financial reporting. Increasingly uses AI and data analytics for audit quality.

Consulting: Helps clients transform their businesses through strategy, technology, and operations. Includes Customer & Marketing, Human Capital, and Strategy & Analytics practices. Deloitte Digital sits within consulting, focusing on digital transformation.

Financial Advisory: Provides M&A, valuation, forensic, and corporate finance services. Helps clients with transactions, disputes, and financial restructuring.

Risk Advisory: Helps organizations navigate risk and regulatory complexity. Includes cyber risk, financial risk, and regulatory strategy.

Tax & Legal: Provides tax planning, compliance, and legal services across jurisdictions.

Key Capabilities: Deloitte's edge comes from combining these services to provide end-to-end solutions. The firm is also investing heavily in AI through its Omnia platform, cloud services, and ESG (Environmental, Social, Governance) advisory."

Q3: How do you handle working in a fast-paced environment?

Q4: Describe a time when you had to analyze complex information.

Q5: How do you approach problem-solving?

Q6: What makes you a good fit for consulting/technology services?

Q7: How do you handle conflicting priorities from multiple stakeholders?

Q8: Tell me about a time you had to learn something quickly.

Q9: What are your thoughts on work-life balance?

Q10: Where do you see yourself in 5 years?

Technical Interview Questions with Answers

Q1: Write a program to find all permutations of a string.

import java.util.ArrayList;
import java.util.List;

public class StringPermutations {
    // Recursive approach
    public static List<String> findPermutations(String str) {
        List<String> result = new ArrayList<>();
        permute(str, 0, str.length() - 1, result);
        return result;
    }
    
    private static void permute(String str, int left, int right, List<String> result) {
        if (left == right) {
            result.add(str);
            return;
        }
        
        for (int i = left; i <= right; i++) {
            str = swap(str, left, i);
            permute(str, left + 1, right, result);
            str = swap(str, left, i); // Backtrack
        }
    }
    
    private static String swap(String str, int i, int j) {
        char[] charArray = str.toCharArray();
        char temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        return String.valueOf(charArray);
    }
    
    // Iterative approach using next permutation
    public static List<String> findPermutationsIterative(String str) {
        List<String> result = new ArrayList<>();
        char[] chars = str.toCharArray();
        java.util.Arrays.sort(chars);
        
        boolean hasNext = true;
        while (hasNext) {
            result.add(new String(chars));
            hasNext = nextPermutation(chars);
        }
        
        return result;
    }
    
    private static boolean nextPermutation(char[] chars) {
        int i = chars.length - 2;
        while (i >= 0 && chars[i] >= chars[i + 1]) {
            i--;
        }
        
        if (i < 0) return false;
        
        int j = chars.length - 1;
        while (chars[j] <= chars[i]) {
            j--;
        }
        
        swap(chars, i, j);
        reverse(chars, i + 1, chars.length - 1);
        return true;
    }
    
    private static void swap(char[] chars, int i, int j) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
    }
    
    private static void reverse(char[] chars, int left, int right) {
        while (left < right) {
            swap(chars, left++, right--);
        }
    }
    
    public static void main(String[] args) {
        String input = "ABC";
        List<String> perms = findPermutations(input);
        System.out.println("Permutations of " + input + ":");
        for (String perm : perms) {
            System.out.println(perm);
        }
    }
}

Time Complexity: O(n × n!) Space Complexity: O(n!) for storing results

Q2: What is the difference between Inner Join and Outer Join?

SELECT e.name, d.department_name
FROM employees e
INNER JOIN departments d ON e.dept_id = d.id;

Only employees with valid department IDs are returned
If no match exists, row is excluded

OUTER JOIN Types:

LEFT OUTER JOIN: All rows from left table, matched rows from right (NULL if no match).

SELECT e.name, d.department_name
FROM employees e
LEFT JOIN departments d ON e.dept_id = d.id;

All employees returned, even those without departments
Unmatched departments show as NULL

RIGHT OUTER JOIN: All rows from right table, matched rows from left.

-- Same as LEFT JOIN with tables reversed

FULL OUTER JOIN: All rows from both tables (NULL where no match).

SELECT * FROM employees e
FULL OUTER JOIN departments d ON e.dept_id = d.id;

Visual Representation:

INNER:      A ∩ B (intersection)
LEFT:       All A, matching B
RIGHT:      Matching A, all B
FULL:       All A, all B

When to use:

INNER: Only need matching records
LEFT: Need all records from main table regardless of matches
FULL: Need complete picture from both tables

Q3: Write a program to implement quick sort.

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // Find partition index
            int pi = partition(arr, low, high);
            
            // Recursively sort elements before and after partition
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }
    
    private static int partition(int[] arr, int low, int high) {
        // Choose rightmost element as pivot
        int pivot = arr[high];
        int i = low - 1; // Index of smaller element
        
        for (int j = low; j < high; j++) {
            // If current element is smaller than or equal to pivot
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        
        // Place pivot in correct position
        swap(arr, i + 1, high);
        return i + 1;
    }
    
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    // Randomized quicksort for better average case
    public static void randomizedQuickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = randomizedPartition(arr, low, high);
            randomizedQuickSort(arr, low, pi - 1);
            randomizedQuickSort(arr, pi + 1, high);
        }
    }
    
    private static int randomizedPartition(int[] arr, int low, int high) {
        int randomIndex = low + (int)(Math.random() * (high - low + 1));
        swap(arr, randomIndex, high);
        return partition(arr, low, high);
    }
    
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("Original: " + java.util.Arrays.toString(arr));
        
        quickSort(arr, 0, arr.length - 1);
        
        System.out.println("Sorted: " + java.util.Arrays.toString(arr));
    }
}

Time Complexity:

Best/Average: O(n log n)
Worst: O(n²) - can be avoided with randomization

Space Complexity: O(log n) - recursion stack

Advantages: In-place, cache-friendly, fastest in practice Disadvantages: Not stable, O(n²) worst case without randomization

Q4: Explain the ACID properties in databases.

Atomicity: All operations in a transaction complete successfully or none do.

Transfer $100: Debit A + Credit B
Either both happen, or neither happens
If debit succeeds but credit fails, entire transaction rolls back

Consistency: Database remains in a consistent state before and after transaction.

If A has $500 and B has $300, total is $800
After transfer, A has $400 and B has $400, total still $800
No constraints violated, all rules preserved

Isolation: Concurrent transactions don't interfere with each other.

Transaction T1 reads account balance
Transaction T2 updates same account
T1 sees consistent snapshot, unaffected by T2 until T2 commits
Isolation levels: Read Uncommitted, Read Committed, Repeatable Read, Serializable

Durability: Once committed, changes persist even in case of system failure.

Transaction commits and writes to transaction log
System crashes immediately after
On recovery, changes are reapplied from log
Committed data is never lost

Importance: ACID ensures data integrity, especially critical for financial transactions, inventory management, and any system where data accuracy is paramount.

Trade-offs: Strict ACID can impact performance. NoSQL databases often relax ACID for scalability (BASE properties)."

Q5: Write a program to find the longest substring without repeating characters.

import java.util.HashSet;
import java.util.Set;

public class LongestSubstring {
    // Sliding window approach - Optimal O(n)
    public static int lengthOfLongestSubstring(String s) {
        Set<Character> set = new HashSet<>();
        int left = 0, right = 0;
        int maxLength = 0;
        
        while (right < s.length()) {
            if (!set.contains(s.charAt(right))) {
                // Expand window
                set.add(s.charAt(right));
                maxLength = Math.max(maxLength, right - left + 1);
                right++;
            } else {
                // Shrink window from left
                set.remove(s.charAt(left));
                left++;
            }
        }
        
        return maxLength;
    }
    
    // Alternative: Return the actual substring
    public static String longestSubstring(String s) {
        Set<Character> set = new HashSet<>();
        int left = 0, right = 0;
        int maxLength = 0;
        int startIndex = 0;
        
        while (right < s.length()) {
            if (!set.contains(s.charAt(right))) {
                set.add(s.charAt(right));
                if (right - left + 1 > maxLength) {
                    maxLength = right - left + 1;
                    startIndex = left;
                }
                right++;
            } else {
                set.remove(s.charAt(left));
                left++;
            }
        }
        
        return s.substring(startIndex, startIndex + maxLength);
    }
    
    // Using array for ASCII (faster for limited charset)
    public static int lengthOfLongestSubstringFast(String s) {
        int[] index = new int[128]; // ASCII
        int maxLength = 0;
        int left = 0;
        
        for (int right = 0; right < s.length(); right++) {
            char c = s.charAt(right);
            left = Math.max(left, index[c]);
            maxLength = Math.max(maxLength, right - left + 1);
            index[c] = right + 1;
        }
        
        return maxLength;
    }
    
    public static void main(String[] args) {
        String s = "abcabcbb";
        System.out.println("Length: " + lengthOfLongestSubstring(s)); // 3 ("abc")
        System.out.println("Substring: " + longestSubstring(s)); // "abc"
    }
}

Time Complexity: O(n) - single pass through string Space Complexity: O(min(m, n)) where m is charset size and n is string length

Sliding Window Technique: Expand right pointer, contract left when duplicate found.

Q6: What is the difference between HashSet and TreeSet?

HashSet:

Set<Integer> hashSet = new HashSet<>();
hashSet.add(3);
hashSet.add(1);
hashSet.add(2);
System.out.println(hashSet); // [1, 2, 3] or any order

Uses hash table implementation
Fastest for add, remove, contains operations
No ordering guarantee

TreeSet:

Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet); // [1, 2, 3] - always sorted

Uses Red-Black tree (self-balancing BST)
Maintains sorted order
Provides range operations: subset(), headSet(), tailSet()
Can use custom Comparator

When to use:

HashSet: When you need fast operations and don't care about order
TreeSet: When you need sorted data or range queries

LinkedHashSet: Middle ground - maintains insertion order with hash table performance."

Q7: Write a SQL query to find the top 3 employees with highest salary in each department.

-- Using window functions (Recommended)
SELECT department_id, employee_name, salary
FROM (
    SELECT 
        department_id,
        employee_name,
        salary,
        DENSE_RANK() OVER (PARTITION BY department_id ORDER BY salary DESC) as rank
    FROM employees
) ranked
WHERE rank <= 3;

-- Alternative using ROW_NUMBER for exactly 3 per department
SELECT department_id, employee_name, salary
FROM (
    SELECT 
        department_id,
        employee_name,
        salary,
        ROW_NUMBER() OVER (PARTITION BY department_id ORDER BY salary DESC) as rn
    FROM employees
) ranked
WHERE rn <= 3;

-- Without window functions (MySQL 5.7 and below)
SELECT e.department_id, e.employee_name, e.salary
FROM employees e
WHERE (
    SELECT COUNT(DISTINCT e2.salary)
    FROM employees e2
    WHERE e2.department_id = e.department_id
    AND e2.salary > e.salary
) < 3;

-- Using correlated subquery with limit per group (not standard)
SELECT e1.department_id, e1.employee_name, e1.salary
FROM employees e1
LEFT JOIN employees e2 
    ON e1.department_id = e2.department_id 
    AND e1.salary < e2.salary
GROUP BY e1.department_id, e1.employee_name, e1.salary
HAVING COUNT(e2.employee_id) < 3;

DENSE_RANK vs ROW_NUMBER:

DENSE_RANK: Gives same rank to ties, may return more than 3 if ties exist
ROW_NUMBER: Arbitrarily assigns unique numbers, exactly 3 per department

Q8: Explain the difference between Synchronous and Asynchronous programming.

Tasks execute sequentially, one at a time
Each operation blocks until completion
Code executes in predictable order
Easier to reason about and debug

// Synchronous
Result r1 = operation1(); // Blocks until done
Result r2 = operation2(); // Blocks until done
Result r3 = operation3(); // Blocks until done

Asynchronous Programming:

Tasks can execute concurrently
Operations don't block; program continues
Results handled via callbacks, promises, or async/await
Better resource utilization for I/O-bound tasks

// Asynchronous (JavaScript style)
operation1()
    .then(result1 => operation2())
    .then(result2 => operation3())
    .then(result3 => console.log("Done"));

Comparison:

Aspect	Synchronous	Asynchronous
Execution	Sequential	Concurrent
Blocking	Yes	No
Complexity	Simpler	More complex
Performance	Slower for I/O	Better for I/O
Debugging	Easier	Harder
Use case	CPU-intensive, simple flow	I/O operations, responsiveness

Java Implementation:

Synchronous: Regular method calls
Asynchronous: CompletableFuture, ExecutorService, reactive programming

When to use Asynchronous:

Network requests
File I/O operations
Database queries
User interface responsiveness

Real-world: Web servers use async to handle many concurrent connections efficiently."

Q9: Write a program to check if a graph has a cycle.

import java.util.*;

public class CycleDetection {
    // For Undirected Graph using DFS
    public static boolean hasCycleUndirected(int vertices, List<List<Integer>> adj) {
        boolean[] visited = new boolean[vertices];
        
        for (int i = 0; i < vertices; i++) {
            if (!visited[i]) {
                if (dfsUndirected(adj, i, visited, -1)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    private static boolean dfsUndirected(List<List<Integer>> adj, int node, 
                                          boolean[] visited, int parent) {
        visited[node] = true;
        
        for (int neighbor : adj.get(node)) {
            if (!visited[neighbor]) {
                if (dfsUndirected(adj, neighbor, visited, node)) {
                    return true;
                }
            } else if (neighbor != parent) {
                // Visited and not parent = cycle
                return true;
            }
        }
        return false;
    }
    
    // For Directed Graph using DFS with recursion stack
    public static boolean hasCycleDirected(int vertices, List<List<Integer>> adj) {
        boolean[] visited = new boolean[vertices];
        boolean[] recursionStack = new boolean[vertices];
        
        for (int i = 0; i < vertices; i++) {
            if (!visited[i]) {
                if (dfsDirected(adj, i, visited, recursionStack)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    private static boolean dfsDirected(List<List<Integer>> adj, int node,
                                        boolean[] visited, boolean[] recStack) {
        visited[node] = true;
        recStack[node] = true;
        
        for (int neighbor : adj.get(node)) {
            if (!visited[neighbor]) {
                if (dfsDirected(adj, neighbor, visited, recStack)) {
                    return true;
                }
            } else if (recStack[neighbor]) {
                // Node in current recursion stack = back edge = cycle
                return true;
            }
        }
        
        recStack[node] = false;
        return false;
    }
    
    public static void main(String[] args) {
        // Test undirected
        int vertices = 4;
        List<List<Integer>> adj = new ArrayList<>();
        for (int i = 0; i < vertices; i++) adj.add(new ArrayList<>());
        adj.get(0).add(1);
        adj.get(1).add(0);
        adj.get(1).add(2);
        adj.get(2).add(1);
        adj.get(2).add(3);
        adj.get(3).add(2);
        adj.get(3).add(0); // Creates cycle
        adj.get(0).add(3);
        
        System.out.println("Has cycle (undirected): " + hasCycleUndirected(vertices, adj));
    }
}

Time Complexity: O(V + E) Space Complexity: O(V)

Methods:

Undirected: DFS tracking parent
Directed: DFS with recursion stack (back edge detection)
Alternative: Topological sort (Kahn's algorithm) for directed

Q10: What is Dependency Injection and why is it useful?

Without DI (tight coupling):

class OrderService {
    private DatabaseConnection db = new DatabaseConnection(); // Tight coupling
    
    public void processOrder() {
        db.save(order);
    }
}

With DI (loose coupling):

class OrderService {
    private DatabaseConnection db;
    
    // Constructor injection
    public OrderService(DatabaseConnection db) {
        this.db = db;
    }
    
    public void processOrder() {
        db.save(order);
    }
}

// Usage
DatabaseConnection db = new DatabaseConnection();
OrderService service = new OrderService(db);

Types of DI:

Constructor Injection: Dependencies via constructor (preferred)
Setter Injection: Dependencies via setters
Interface Injection: Dependencies via interface methods

Benefits:

Loose Coupling: Components depend on abstractions, not concrete implementations
Testability: Easy to mock dependencies for unit testing
Flexibility: Swap implementations without changing dependent code
Maintainability: Changes to dependencies don't cascade through codebase
Reusability: Components can be reused in different contexts

Frameworks: Spring (Java), Angular (TypeScript), various IoC containers

Principle: "Don't call us, we'll call you" - Hollywood Principle"

Managerial/Behavioral Questions with Answers

Q1: How would you handle a situation where a client is unhappy with your work?

Q2: Describe a time you had to persuade someone to see things your way.

Q3: How do you prioritize your professional development?

Q4: Tell me about a time you worked with a diverse team.

Q5: What would you do if you realized you made a significant error?

Tips for Cracking Deloitte Interview

Understand Professional Services: Deloitte is a consulting firm, not just an IT company. Show appreciation for client service, business impact, and advisory work.
Game-Based Assessment: Deloitte uses game-based cognitive assessments. Practice pattern recognition, numerical reasoning, and logical puzzles.
Group Discussion Excellence: GD is crucial at Deloitte. Practice structured thinking, active listening, building on others' points, and summarizing discussions.
English Proficiency: The Versant test assesses spoken English. Practice pronunciation, fluency, and comprehension with English media and conversations.
Case Study Basics: Be prepared for mini case studies - structure your thinking, ask clarifying questions, and show logical problem decomposition.
Aptitude Mastery: Focus heavily on quantitative aptitude, logical reasoning, and verbal ability. Deloitte's tests are challenging.
Know Deloitte Deeply: Research recent Deloitte initiatives, acquisitions, and industry focus areas. Show genuine interest in their work.
Professional Presence: Dress formally, maintain professional demeanor, and demonstrate the polish expected in client-facing roles.
Business Acumen: Show interest in how technology drives business value, not just technical implementation.
Be Authentic: Deloitte values diversity of thought. Don't try to fit a mold - show your unique perspective and strengths.

Frequently Asked Questions ( FAQs)

Q1: What is the salary package for freshers at Deloitte? A: Typically ranges from 4.5 LPA to 7.5 LPA depending on the role (Analyst, Business Technology Analyst) and office location.

Q2: Is there a service bond at Deloitte? A: Generally no formal bond, but check specific offer letter terms. Deloitte typically doesn't require service agreements.

Q3: What is the Deloitte game-based assessment? A: It's a series of cognitive games testing pattern recognition, numerical reasoning, memory, and logical thinking. Practice similar games online.

Q4: How important is the Group Discussion round? A: Very important. Deloitte uses GD to assess communication, leadership potential, teamwork, and structured thinking - all critical for consulting roles.

Q5: What is Deloitte University? A: Deloitte's global learning organization providing training, professional development, and leadership programs for employees throughout their careers.

Best of luck with your Deloitte interview preparation!