cswork / libraryOpen practice workspace

Interview guides · Deloitte

Deloitte Software Engineer Interview Guide

Deloitte Software Engineer interview guide: reported rounds, questions and how candidates describe the process.

The 60-second brief

A Software Engineer at Deloitte operates at the intersection of complex problem-solving and large-scale digital transformation. You are not merely writing code; you are building robust, scalable solutions that address critical business challenges for global clients. Your work directly impacts how organizations manage their data, infrastructure, and digital presence, making this a role of significant strategic influence. The environment is fast-paced and collaborative, often requiring you to bridge the gap between technical implementation and business requirements. Whether you are working on cloud migrations, microservices architectures, or enterprise-level application development, you will be expected to balance technical rigor with an understanding of the end-user’s needs.

This guide is scoped to a Software Engineer candidate at Deloitte.

Focus areas

  • Java
  • Problem Solving
  • Coding Fundamentals / Programming Fundamentals

The Deloitte interview process

Deloitte candidates report 3 rounds over 3-5 weeks. The stages below are what candidates describe, not a published process.

Recruiter Screen

Initial screening by a recruiter to assess candidate fit for the role.

What to demonstrate

  • Initial screening by a recruiter to assess candidate fit for the role
  • Depth in Java

How to prepare

  • Be able to walk your CV end to end in two minutes, and say why this company specifically.
  • Have your salary expectations, notice period and location constraints ready, and ask for the rest of the loop in writing.

Technical Assessments

Includes online coding tests or AI-driven interviews to evaluate technical skills.

What to demonstrate

  • Includes online coding tests or AI-driven interviews to evaluate technical skills
  • Depth in Java

How to prepare

  • Answer aloud and timed: How do you approach debugging a complex application in a production environment?
  • Answer aloud and timed: Describe your experience with Cloud services (e.g., AWS, Azure) and their role in modern architecture.

Deep-Dive Interviews

Series of in-depth technical and managerial conversations to assess overall fit.

What to demonstrate

  • Series of in-depth technical and managerial conversations to assess overall fit
  • Depth in Java

How to prepare

  • Answer aloud and timed: How do you handle polymorphism and inheritance in your preferred programming language?
  • Answer aloud and timed: Given a string, return the minimum number of substrings such that no letter occurs more than once in each substring.

Where candidates lose points

Project Ownership

Be prepared to talk about your projects in depth. Interviewers will ask about the challenges you faced and the specific technical decisions you made.

Structure Your Answers

Use the STAR method (Situation, Task, Action, Result) for all behavioral questions to ensure your answers are organized and impactful.

Understand the Business

Research the specific industry or client type mentioned in the job description to show you understand the context of the work.

Clarify Requirements

If a question seems ambiguous, ask clarifying questions before jumping into a solution. This demonstrates strong engineering discipline.

Questions & practice

Given a string, return the minimum number of substrings such that no letter occurs more than once in each subs

Medium · Coding & Problem Solving

Given a string, return the minimum number of substrings such that no letter occurs more than once in each substring.

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

Walk me through your approach to solving a LeetCode-style coding challenge.

Medium · Coding & Problem Solving

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

How do you optimize a function that is experiencing high latency?

Medium · Coding & Problem Solving

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

Explain your logic for handling duplicate data detection within a data structure.

Medium · Coding & Problem Solving

Approach

  1. Restate the input: its shape, its size, and what is guaranteed about it.
  2. Name the brute-force solution and its complexity before improving on it.
  3. Choose the data structure from the access pattern, not from familiarity.
  4. State the target complexity and say which constraint rules the naive version out.

Follow-up

  • How does this change if the input no longer fits in memory?
  • What is the worst case, and how likely is it on real data?

What are the key differences between SQL and NoSQL databases?

Medium · Technical & Domain Knowledge

Approach

  1. Name the grain you start from and join outward from it.
  2. Check whether any join is one-to-many before aggregating, or the sums inflate.
  3. Say which index the query would use, and what makes it unusable.
  4. Handle the rows that do not match: that is usually the actual question.

Follow-up

  • How does the query change if that join becomes one-to-many?
  • What happens to this when the table is ten times larger?

Hold a per-tenant active cap against concurrent creates

Hard · write skew · isolation levels · constraints

A tenant on the standard plan may hold at most 50 resources with status='active'. The create handler runs SELECT count(*) FROM resource WHERE tenant_id = $1 AND status = 'active', compares to 50, then inserts. Two creates arrive 3 ms apart on different instances and the tenant lands at 51. Name the anomaly, say whether PostgreSQL 16 READ COMMITTED or REPEATABLE READ prevents it and why, then give an implementation that holds the cap at READ COMMITTED with the exact statements. Finally, say what changes when the cap is 'at most one running export per tenant' on job_run.

Approach

  1. Name it: write skew. The two transactions read an overlapping set and write disjoint rows, so there is no row-level conflict for the engine to detect and each commit is individually legal.
  2. Rule out the levels precisely. READ COMMITTED takes a fresh snapshot per statement and takes no lock on the counted rows, so both see 49. PostgreSQL's REPEATABLE READ is snapshot isolation: it removes non-repeatable reads and phantoms within the snapshot but still admits write skew, because the anomaly is not a re-read of a changed row, it is a read of a set that a concurrent transaction invalidates. Only SERIALIZABLE closes it, by tracking the read dependency and aborting one transaction with SQLSTATE 40001 — a guarantee that exists only if the application re-runs the whole transaction from the read.
  3. Convert the set predicate into a single-row conflict: keep tenant.active_resource_count and run UPDATE tenant SET active_resource_count = active_resource_count + 1 WHERE tenant_id = $1 AND active_resource_count < 50 in the same transaction as the INSERT. Zero affected rows is the cap, returned as 409. The row lock serialises the decision at any isolation level, and contention is bounded to one tenant's row — which is also the fair-scheduling unit, unlike a global counter that would convoy every tenant behind one row.
  4. State the cost you just took on: a counter is a second source of truth that can drift, so every path that changes status must adjust it inside the same transaction, and a periodic reconciliation has to exist, with resource_revision as the authority for what the count should have been.

Follow-up

  • A resource moves from archived back to active. Which statements change, and what breaks if the counter update and the status change land in different transactions?
  • The cap becomes plan-dependent and a plan can change mid-month. Where does the number 50 live, and who reads it?

Explain the principles of Object-Oriented Programming (OOP) and how you apply them in your projects.

Medium · Technical & Domain Knowledge

Approach

  1. Clarify what is being asked and what a complete answer contains.
  2. State your assumptions explicitly before working the problem.
  3. Say what you would check first and why it is the highest-information step.
  4. Work from the requirement backwards to the design.

Follow-up

  • What assumption would you test first?
  • How would you know your answer was wrong?

Convert the listing endpoint from offset pages to stable cursors

Medium · pagination · cursors · index access path

GET /v1/resources returns a tenant's resources newest-updated first, today with page and per_page, backed by index (tenant_id, status, updated_at DESC, resource_id DESC). Callers are a browser feed and a nightly sync job that walks every page. Users report items appearing twice or vanishing between pages, and page 400 is slow. Design the cursor contract: what the cursor contains and how it is encoded, the exact WHERE and ORDER BY, what happens when a row's updated_at changes mid-walk, how a client detects the end, and what the sync job does when a cursor is rejected.

Approach

  1. Separate the two defects, because they have different fixes. Cost: OFFSET n makes the engine produce and discard n rows, so price grows with page depth rather than page size and page 400 pays for 400 pages of work. Correctness: while the set shifts, rows cross the offset boundary and are skipped or repeated, and nothing in the response lets the client detect it.
  2. Write the seek: WHERE tenant_id = $1 AND status = $2 AND (updated_at, resource_id) < ($k, $id) ORDER BY updated_at DESC, resource_id DESC LIMIT n. The tie-break is not decoration - updated_at is not unique, and two rows sharing a timestamp across a page boundary reintroduce exactly the skip this was adopted to remove. PostgreSQL seeks the composite index on the row-value comparison directly; on an engine that does not optimise a row constructor, expand it into the equivalent OR form or the plan quietly degrades to a scan.
  3. Encode the cursor as an opaque token carrying the sort key, the id, and a fingerprint of the filter and sort order, signed or at minimum validated. A cursor replayed against a different sort or filter must be a 400 with its own code, not a silently wrong page - the sync job cannot notice the difference otherwise.
  4. State the guarantee precisely rather than generously. Keyset is stable against inserts and deletes elsewhere in the set, because the position is a value and not a count. It is not a snapshot: updated_at is mutable, so a row that is edited during the walk re-sorts and may be seen twice or not at all. If the sync job needs exactly-once coverage, order on an immutable key such as (created_at, resource_id), or walk resource_revision by revision_id and treat updated_at as data.

Follow-up

  • The client wants a total count and the ability to jump to page 400. What can you honestly offer instead, and what does each option cost?
  • How do you paginate backwards, and what does that require of the index?

How do you approach debugging a complex application in a production environment?

Medium · Technical & Domain Knowledge

Approach

  1. Establish what changed and when, before forming any theory.
  2. Pick a bisection that eliminates candidates whichever way it turns out.
  3. Check the instrumentation before believing the symptom.
  4. Separate the trigger from the cause; the deploy is rarely the bug.

Follow-up

  • What would you look at first, and what would it rule out?
  • How would you tell a cause from a coincidence here?

Suggested practice checklist

Built from the rounds and topics Deloitte candidates report.

Day 1 — Map the Deloitte loop

  • Write out the reported sequence: Recruiter Screen, Technical Assessments, Deep-Dive Interviews.
  • For each round, write one sentence on what it is judging, from the description above, and mark the one you are least ready for.

Deliverable: A one-page map of the 3 reported rounds, with the weakest marked.

Day 2 — Work Java

  • Spend the session on Java, which Deloitte candidates report being tested on.
  • Write one worked example in Java and time yourself on it.

Deliverable: One timed worked example in Java.

Day 3 — Work Problem Solving

  • Spend the session on Problem Solving, which Deloitte candidates report being tested on.
  • Write one worked example in Problem Solving and time yourself on it.

Deliverable: One timed worked example in Problem Solving.

Day 4 — Work Coding Fundamentals / Programming Fundamentals

  • Spend the session on Coding Fundamentals / Programming Fundamentals, which Deloitte candidates report being tested on.
  • Write one worked example in Coding Fundamentals / Programming Fundamentals and time yourself on it.

Deliverable: One timed worked example in Coding Fundamentals / Programming Fundamentals.

Day 5 — Answer out loud: Technical & Domain Knowledge

  • Answer aloud, timed: Explain the principles of Object-Oriented Programming (OOP) and how you apply them in your projects.
  • Answer aloud, timed: What are the key differences between SQL and NoSQL databases?

Deliverable: Spoken answers to 2 reported Technical & Domain Knowledge question(s), under time.

Day 6 — Answer out loud: Coding & Problem Solving

  • Answer aloud, timed: Given a string, return the minimum number of substrings such that no letter occurs more than once in each substring.
  • Answer aloud, timed: Walk me through your approach to solving a LeetCode-style coding challenge.

Deliverable: Spoken answers to 2 reported Coding & Problem Solving question(s), under time.

Day 7 — Answer out loud: Behavioral & Leadership

  • Answer aloud, timed: Tell me about a time you had to handle a disagreement within your team.
  • Answer aloud, timed: Why are you interested in joining Deloitte specifically?

Deliverable: Spoken answers to 2 reported Behavioral & Leadership question(s), under time.

Behavioural preparation

Behavioural rounds judge the decision you made and what it cost.

Describe your experience with Cloud services (e.g., AWS, Azure) and their role in modern architecture.

Medium · Technical & Domain Knowledge

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

How do you handle polymorphism and inheritance in your preferred programming language?

Medium · Technical & Domain Knowledge

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

Tell me about a time you had to handle a disagreement within your team.

Medium · Behavioral & Leadership

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

Why are you interested in joining Deloitte specifically?

Medium · Behavioral & Leadership

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

Describe a project where you faced a significant technical challenge; how did you overcome it?

Medium · Behavioral & Leadership

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?

How do you communicate technical constraints to non-technical stakeholders?

Medium · Behavioral & Leadership

Approach

  1. Pick a story where you made the decision, not one where you watched it.
  2. State the situation in two sentences and spend the rest on the reasoning.
  3. Give the blast radius: what could have broken, and what you measured.
  4. Name the disagreement and how you resolved it with evidence.

Follow-up

  • What would you do differently if you ran that again?
  • How did you know your change caused the improvement?