Deloitte Data Engineer Interview Guide

Deloitte data engineers don't own a product. They own a rotation. One quarter you're building Airflow DAGs for a federal agency's audit pipeline in Arlington, the next you're wiring Kafka consumers into a retail client's inventory reconciliation system. That constant context-switching, not algorithm skill, is what actually separates hires from rejections in this process.

Deloitte Data Engineer Role

Your job is to land inside a client's existing data environment, stand up pipelines (Airflow, NiFi, Lambda-triggered SQS-to-S3 ingestion paths), and produce curated analytics-ready tables that feed Tableau or Power BI dashboards for stakeholders who've never heard of an orchestration framework. Success after year one means you've shipped at least one engagement from ingestion through governed dashboard publishing, and the client's own team can operate your pipelines using only the runbooks you left behind.

A Typical Week

The breakdown that catches product-company engineers off guard is how much time goes to writing: runbooks in Confluence, technical design docs that need engagement lead sign-off before new architecture reaches the client, and on-call handoff notes. Coding still claims the biggest share, but the documentation load is real because Deloitte's delivery model assumes you'll eventually roll off and someone else inherits your work.

Projects & Impact Areas

A Databricks lakehouse engagement for a healthcare analytics platform and a flaky NiFi processor debug for a federal agency requiring TS/SCI clearance feel like different jobs, but Deloitte's Government & Public Services practice can put both on adjacent sprints. AWS-native stacks (Glue, Redshift, S3, Lambda) show up frequently in public sector work, while enterprise retail clients might need you writing deconfliction logic for overlapping inventory systems with conflicting timestamps and entity IDs. The variety is genuine, though the tradeoff is equally real: you rarely see how your pipeline performs six months after you roll off.

Skills & What's Expected

ML and GenAI score "medium" in Deloitte's own postings, and senior roles do mention RAG, vector databases, and NLP tooling. But for the majority of open data engineer seats, your time goes to SQL, Python, Spark, and cloud infrastructure, not model training. The skill that actually filters candidates is data visualization and stakeholder communication: republishing governed Tableau dashboards, translating a CFO's vague request into a data model, and explaining SLA breaches to non-technical clients.

Levels & Career Growth

The jump that trips people up is Senior Consultant to Manager. Below that line, promotions reward delivery quality and technical depth. Above it, the evaluation shifts toward scoping, estimation, risk management, and whether clients trust you to own their workstream. Utilization rates and client feedback can speed up or stall the timeline at every level, so strong delivery on a high-visibility engagement matters more than simply logging years.

Work Culture

Deloitte describes the model as hybrid with the ability to work in-office or at the client site three days per week, but client demands override that baseline. If the engagement needs you on-site in Dallas, you're in Dallas. The career ladder is unusually legible compared to tech companies, and internal learning hours (like a Friday session on Kubernetes orchestration patterns) do happen.

The honest downside: your team dissolves when projects end, utilization pressure spikes during go-lives and audit season, and late evenings happen without much ceremony. It's a setup that rewards people who thrive on variety and wears down people who want deep, long-term ownership of one system.

Deloitte Data Engineer Compensation

From what's publicly available, Deloitte doesn't appear to offer RSUs or a stock purchase program for data engineers. The Big 4 are known for reserving equity-like compensation for the partnership track. Your total comp is base + annual performance bonus + benefits, which makes the math simpler but removes the upside optionality that equity-heavy tech offers provide.

Base salary is your single biggest negotiation lever. The offer negotiation data confirms that base (within band for your level), sign-on bonus, and title/level alignment are all on the table. Bring a competing offer and quantify niche platform skills like Databricks or Snowflake experience, since recruiters are told to factor in specialized expertise when positioning you within band. One move worth trying: ask whether a sign-on bonus is available before you anchor on base, and push for Senior Consultant over Consultant if your experience supports it, because that level shift drops you into an entirely different salary band.

Deloitte Data Engineer Interview Process

Candidates who over-index on algorithm prep tend to struggle here. Deloitte's rounds reward applied engineering judgment shaped by consulting delivery constraints: designing incremental loads against messy client source systems, explaining SCD Type 2 tradeoffs to a hiring manager who thinks like a client advisor, and showing you can operationalize a pipeline (monitoring, idempotency, data quality gates) for a team that will eventually own it without you.

Leveling is evaluated after your interviews end, and you won't be in the room. From what candidates report, the post-interview debrief includes a calibration on whether your examples demonstrated scope appropriate to the level you're targeting. If your stories emphasize task-level execution but you interviewed for Senior Consultant, reviewers may downlevel you to Consultant rather than reject outright. Calibrate every answer to the ownership and complexity you want credited.

Deloitte Data Engineer Interview Questions

1/*
2Assumptions:
3- Staging table: stg_orders
4  Columns: order_id, customer_id, order_status, order_amount, updated_at, ingest_date
5- Target fact table load is derived from deduped staging.
6- "Yesterday" is based on current_date.
7*/
8WITH deduped AS (
9  SELECT
10    o.order_id,
11    o.customer_id,
12    o.order_status,
13    o.order_amount,
14    o.updated_at,
15    o.ingest_date,
16    ROW_NUMBER() OVER (
17      PARTITION BY o.order_id
18      ORDER BY o.updated_at DESC
19    ) AS rn
20  FROM stg_orders o
21  WHERE o.ingest_date = (CURRENT_DATE - INTERVAL '1 day')
22), curated_yesterday AS (
23  SELECT
24    order_id,
25    customer_id,
26    order_status,
27    order_amount,
28    updated_at,
29    ingest_date
30  FROM deduped
31  WHERE rn = 1
32)
33SELECT
34  ingest_date,
35  COUNT(*) AS curated_row_count,
36  COUNT(DISTINCT order_id) AS curated_distinct_order_count
37FROM curated_yesterday
38GROUP BY ingest_date;

1/*
2Assumptions:
3- Table: inv_events
4  Columns:
5    sku_id,
6    warehouse_id,
7    event_ts,
8    event_id,          -- tie breaker for same timestamp
9    qty_delta          -- positive for receipts, negative for issues/transfers out
10- You want the first time the running balance goes negative in the last 7 days.
11*/
12WITH recent AS (
13  SELECT
14    e.sku_id,
15    e.warehouse_id,
16    e.event_ts,
17    e.event_id,
18    e.qty_delta
19  FROM inv_events e
20  WHERE e.event_ts >= (CURRENT_TIMESTAMP - INTERVAL '7 day')
21), with_running AS (
22  SELECT
23    r.sku_id,
24    r.warehouse_id,
25    r.event_ts,
26    r.event_id,
27    r.qty_delta,
28    SUM(r.qty_delta) OVER (
29      PARTITION BY r.sku_id, r.warehouse_id
30      ORDER BY r.event_ts, r.event_id
31      ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
32    ) AS on_hand_running
33  FROM recent r
34), violations AS (
35  SELECT
36    sku_id,
37    warehouse_id,
38    event_ts,
39    event_id,
40    on_hand_running,
41    ROW_NUMBER() OVER (
42      PARTITION BY sku_id, warehouse_id
43      ORDER BY event_ts, event_id
44    ) AS rn
45  FROM with_running
46  WHERE on_hand_running < 0
47)
48SELECT
49  sku_id,
50  warehouse_id,
51  event_ts AS first_negative_ts,
52  on_hand_running AS first_negative_on_hand
53FROM violations
54WHERE rn = 1
55ORDER BY first_negative_ts, sku_id, warehouse_id;

1import os
2import json
3import time
4import uuid
5import logging
6from dataclasses import dataclass
7
8import boto3
9import psycopg2
10
11
12class JsonFormatter(logging.Formatter):
13    def format(self, record: logging.LogRecord) -> str:
14        payload = {
15            "ts": int(record.created * 1000),
16            "level": record.levelname,
17            "logger": record.name,
18            "msg": record.getMessage(),
19        }
20        for k in ("run_id", "job", "s3_key", "step", "rows", "duration_ms"):
21            if hasattr(record, k):
22                payload[k] = getattr(record, k)
23        if record.exc_info:
24            payload["exc"] = self.formatException(record.exc_info)
25        return json.dumps(payload)
26
27
28def get_logger() -> logging.Logger:
29    logger = logging.getLogger("etl")
30    if not logger.handlers:
31        logger.setLevel(os.getenv("LOG_LEVEL", "INFO"))
32        h = logging.StreamHandler()
33        h.setFormatter(JsonFormatter())
34        logger.addHandler(h)
35    return logger
36
37
38@dataclass(frozen=True)
39class Config:
40    job: str
41    s3_bucket: str
42    s3_key: str
43    local_path: str
44    pg_dsn: str
45    max_attempts: int = 4
46    base_backoff_s: float = 1.0
47
48
49def retry(fn, *, max_attempts: int, base_backoff_s: float, logger: logging.Logger, **logctx):
50    attempt = 1
51    while True:
52        try:
53            return fn()
54        except Exception:
55            logger.exception(
56                "step_failed",
57                extra={**logctx, "attempt": attempt, "max_attempts": max_attempts},
58            )
59            if attempt >= max_attempts:
60                raise
61            time.sleep(base_backoff_s * (2 ** (attempt - 1)))
62            attempt += 1
63
64
65def download_s3(cfg: Config, logger: logging.Logger, run_id: str):
66    s3 = boto3.client("s3")
67
68    def _do():
69        s3.download_file(cfg.s3_bucket, cfg.s3_key, cfg.local_path)
70
71    t0 = time.time()
72    retry(
73        _do,
74        max_attempts=cfg.max_attempts,
75        base_backoff_s=cfg.base_backoff_s,
76        logger=logger,
77        run_id=run_id,
78        job=cfg.job,
79        step="download_s3",
80        s3_key=cfg.s3_key,
81    )
82    logger.info(
83        "step_ok",
84        extra={
85            "run_id": run_id,
86            "job": cfg.job,
87            "step": "download_s3",
88            "s3_key": cfg.s3_key,
89            "duration_ms": int((time.time() - t0) * 1000),
90        },
91    )
92
93
94def copy_to_postgres(cfg: Config, logger: logging.Logger, run_id: str, table: str):
95    def _do():
96        conn = psycopg2.connect(cfg.pg_dsn)
97        try:
98            with conn, conn.cursor() as cur, open(cfg.local_path, "r", encoding="utf-8") as f:
99                cur.copy_expert(f"COPY {table} FROM STDIN WITH (FORMAT csv, HEADER true)", f)
100        finally:
101            conn.close()
102
103    t0 = time.time()
104    retry(
105        _do,
106        max_attempts=cfg.max_attempts,
107        base_backoff_s=cfg.base_backoff_s,
108        logger=logger,
109        run_id=run_id,
110        job=cfg.job,
111        step="copy_postgres",
112        s3_key=cfg.s3_key,
113    )
114    logger.info(
115        "step_ok",
116        extra={
117            "run_id": run_id,
118            "job": cfg.job,
119            "step": "copy_postgres",
120            "duration_ms": int((time.time() - t0) * 1000),
121        },
122    )
123
124
125def main():
126    logger = get_logger()
127    run_id = os.getenv("RUN_ID") or str(uuid.uuid4())
128
129    cfg = Config(
130        job=os.getenv("JOB_NAME", "nightly_orders_csv"),
131        s3_bucket=os.environ["S3_BUCKET"],
132        s3_key=os.environ["S3_KEY"],
133        local_path=os.getenv("LOCAL_PATH", "/tmp/extract.csv"),
134        pg_dsn=os.environ["PG_DSN"],
135    )
136
137    logger.info("job_start", extra={"run_id": run_id, "job": cfg.job, "s3_key": cfg.s3_key})
138    download_s3(cfg, logger, run_id)
139    copy_to_postgres(cfg, logger, run_id, table="stg_orders")
140    logger.info("job_ok", extra={"run_id": run_id, "job": cfg.job})
141
142
143if __name__ == "__main__":
144    main()
145

What stands out here isn't any single dominant topic. It's that Deloitte's questions consistently drop you into a client scenario (retail ordering, government program reporting, healthcare eligibility) and ask you to solve across layers: schema design, pipeline logic, SQL validation, and stakeholder explanation all within the same problem. The prep mistake candidates report most often is drilling abstract coding problems when these rounds reward walking through a messy, real-engagement delivery end to end. From what the distribution suggests, even the cloud and Python questions are framed around constrained client environments (VPN restrictions, inherited codebases, security baselines), not clean-room architecture exercises.

Practice with scenario-based questions like these at datainterview.com/questions.

How to Prepare for Deloitte Data Engineer Interviews

Deloitte generated $70.5 billion in global revenue and has committed more than €1.5 billion in incremental investment toward GenAI, sovereign cloud capability, and sector-specific solutions. For data engineers, that investment translates into concrete engagement types: Databricks lakehouse builds for consulting clients, AWS-native pipelines for federal agencies (some requiring TS/SCI clearance), and the data infrastructure backing Deloitte's own State of AI in the Enterprise advisory offerings.

The "why Deloitte" answer that falls flat is any version of "I want to build scalable data platforms." That could describe a role at Snowflake or Spotify. What separates Deloitte is the delivery-and-transition model: you architect a pipeline for a healthcare client's Databricks environment, write the runbooks, then hand ownership to their internal team while you rotate to a federal data modernization project on a completely different stack. Anchor your answer to that rhythm, and reference a specific investment area (GenAI enablement, sovereign cloud) to show you've done your homework on where the firm is heading.

Try a Real Interview Question

1WITH ranked AS (
2  SELECT
3    order_id,
4    customer_id,
5    order_status,
6    amount,
7    event_ts,
8    op,
9    ROW_NUMBER() OVER (
10      PARTITION BY order_id
11      ORDER BY
12        event_ts DESC,
13        CASE op
14          WHEN 'U' THEN 3
15          WHEN 'I' THEN 2
16          WHEN 'D' THEN 1
17          ELSE 0
18        END DESC
19    ) AS rn
20  FROM order_cdc
21)
22SELECT
23  order_id,
24  customer_id,
25  order_status,
26  amount,
27  event_ts
28FROM ranked
29WHERE rn = 1
30  AND op <> 'D'
31ORDER BY order_id;

From what candidates report, Deloitte's technical rounds lean toward scenario-based SQL and Python that reflect client delivery work, not competitive programming. Sharpen that muscle at datainterview.com/coding, where the problems skew toward applied data engineering rather than abstract algorithms.

Test Your Readiness

Spot your weak areas here, then close the gaps with Deloitte-relevant practice questions at datainterview.com/questions.