Deloitte Interview Questions 2026

Last Updated: March 2026

Truth check — what actually matters for Deloitte 2026

Deloitte India's USI (US India) and Consulting (S&O) tracks operate as different funnels, and the prep should not be conflated. USI is technology-services-style, S&O is management-consulting-style, and the latter has roughly half the headcount of the former.

The 2026 snapshot: ~1,700 active roles tracked. USI dominates this count. Consulting hiring is smaller-volume but premium-positioned.

What guides get wrong: the USI assessment is closer to a tier-1 service-IT format (aptitude + technical MCQ + 1 coding) than the conventional "consulting case interview" prep. If you are coming from BCG/McKinsey-prep mindset, you are over-prepping for USI and under-prepping for the right thing.

For USI Technology Analyst roles, the technical interview tilts toward SQL and ETL fundamentals. SAP, Salesforce, and Oracle ecosystem knowledge differentiates. If your final-year project touched any of these, lead with it.

The case interview only matters for S&O roles. Standard McKinsey-PST / Bain-case prep applies. The Deloitte-specific case style favors structured-frameworks (Profitability, Market Entry, M&A) over creative problem-solving.

The HR round at Deloitte is highly behavioral, STAR format with 3-5 examples per competency expected. Candidates who answer with one example per question score lower than candidates with multiple-example fluency.

If you have 2 weeks for Deloitte USI only: 4 days of SQL + ETL fundamentals; 4 days of LeetCode-easy/medium DSA; 3 days of business-fundamentals (financial-services context, basic accounting); 3 days of behavioral STAR with multi-example fluency.

Deloitte Selection Process Overview

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:

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:

1. Constructor Injection: Dependencies via constructor (preferred)
2. Setter Injection: Dependencies via setters
3. 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

1. Understand Professional Services: Deloitte is a consulting firm, not just an IT company. Show appreciation for client service, business impact, and advisory work.

2. Game-Based Assessment: Deloitte uses game-based cognitive assessments. Practice pattern recognition, numerical reasoning, and logical puzzles.

3. Group Discussion Excellence: GD is crucial at Deloitte. Practice structured thinking, active listening, building on others' points, and summarizing discussions.

4. English Proficiency: The Versant test assesses spoken English. Practice pronunciation, fluency, and comprehension with English media and conversations.

5. Case Study Basics: Be prepared for mini case studies - structure your thinking, ask clarifying questions, and show logical problem decomposition.

6. Aptitude Mastery: Focus heavily on quantitative aptitude, logical reasoning, and verbal ability. Deloitte's tests are challenging.

7. Know Deloitte Deeply: Research recent Deloitte initiatives, acquisitions, and industry focus areas. Show genuine interest in their work.

8. Professional Presence: Dress formally, maintain professional demeanor, and demonstrate the polish expected in client-facing roles.

9. Business Acumen: Show interest in how technology drives business value, not just technical implementation.

10. Be Authentic: Deloitte values diversity of thought. Don't try to fit a mold - show your unique perspective and strengths.

You May Also Like

• Stack and Queue Interview Questions 2026
• Top 50 Data Structures Interview Questions 2026
• Intel Interview Questions 2026 - Round-by-Round Guide
• Prompt Engineering Interview Questions 2026, Top 50 Questions with Answers

🎯 Live Mock Test, May 2026 Edition

5 original questions written by Aditya Sharma, calibrated to the Deloitte 2026 batch difficulty. Click any option to lock your answer; solutions reveal after.