Intuit Data Engineer Interview Guide

Intuit's data engineering interviews include two separate behavioral rounds plus a case study, which is unusual for a DE role. That structure tells you something about the job itself: you'll spend nearly as much time in cross-functional alignment and documentation as you will writing Spark jobs, because the pipelines you build feed products where financial correctness has real consequences for small business owners and tax filers.

Intuit Data Engineer Role

You're building and maintaining the pipelines that connect Intuit's product ecosystem: batch jobs feeding QuickBooks financial dashboards, streaming ingestion for Credit Karma fraud signals, dbt models powering Mailchimp campaign analytics. Success after year one means your downstream consumers (analysts, ML engineers, product managers) trust the tables you own, your pipelines survive tax season without constant paging, and you've shipped at least one data integration that connects work across product lines.

A Typical Week

The infrastructure slice is what catches people off guard. You might picture a data engineer spending most of their time writing PySpark, but a significant chunk of every week goes to SLA monitoring, Airflow DAG hygiene, S3 bucket cleanup, and on-call handoffs. The cross-functional load is real too. Wednesday's design review with the Credit Karma ML team and Thursday's pair session debugging a SageMaker Feature Store timestamp issue aren't interruptions to your "real work." They are the work.

Projects & Impact Areas

Intuit's GenAI initiative means data engineers are building foundational data layers that AI features consume, alongside more traditional platform work. Trust and Safety is a growing area (there are Staff DE postings in this space), with fraud detection pipelines that balance low latency against accuracy on sensitive financial transactions. Then there's the less glamorous but equally critical work: maintaining QuickBooks subscription revenue fact tables that finance validates against their source of truth before month-end close, where a missed row is a compliance conversation, not just a bad chart.

Skills & What's Expected

Business acumen about financial data separates strong candidates from adequate ones. The skill profile demands expert-level software engineering, data architecture, and cloud infrastructure across AWS, GCP, or Azure, with tools like Snowflake and Databricks featuring prominently in the stack. Don't neglect algorithms, though. The interview process includes an online assessment covering data structures and algorithms, so while your day-to-day won't be LeetCode-style optimization, you need to clear that bar to reach the rounds where domain knowledge shines.

Levels & Career Growth

Senior Data Engineer, Staff, and Senior Staff are distinct career milestones. The jump to Staff requires owning cross-team platform decisions (like a schema migration strategy affecting multiple product lines), not just delivering excellent individual pipeline work. Intuit's breadth across tax, fintech, and marketing automation means you can move laterally into a genuinely different domain without leaving the company.

Work Culture

Intuit operates a hybrid model, with candidates and culture notes pointing to roughly 2-3 in-office days per week at your assigned hub. From what candidates report, the pace outside of tax season (January through April) is sustainable, with many engineers wrapping up by early evening. Filing season is a different story for TurboTax-adjacent teams, bringing pipeline load spikes and tighter on-call expectations. The company's operating values (Integrity Without Compromise, Courage, Customer Obsession, Stronger Together, We Care And Give Back) aren't decorative. Behavioral interviews explicitly probe for them across two dedicated rounds, so you'll need distinct stories for each.

Intuit Data Engineer Compensation

Intuit's RSUs vest over four years, and from what candidates report, the first-year schedule is often front-loaded to make the initial offer more attractive. The annual bonus percentage is fixed at each level, so don't waste negotiation capital trying to move it. Focus your energy on the RSU grant and base salary, which are the two components with real flexibility.

Your strongest negotiation move is anchoring on total compensation with a competing offer in hand. The RSU grant, in particular, has more room to move than base when you can point to a concrete alternative package. Frame every ask around the full picture (base plus equity plus bonus) rather than fixating on any single line item, because that's the lens Intuit's comp team uses internally.

Intuit Data Engineer Interview Process

Plan for about five weeks end-to-end. The case study round is where most damage happens, from what candidates report. You get a technical problem roughly 90 minutes before presenting to four hiring team members, and the format rewards architecture thinking and clear communication just as much as code quality. Treating it as purely a coding exercise or purely a design discussion will hurt you, since the round explicitly covers algorithms, data structures, system design, and pipeline architecture together.

The double-behavioral format is the other trap. Two separate rounds probe different angles: one digs into your technical depth with follow-ups tied to your case study solution, while the other focuses on collaboration and how you operate on a team building pipelines for products like QuickBooks or Credit Karma. Candidates who recycle the same three STAR stories across both rounds run out of material fast.

Intuit Data Engineer Interview Questions

1-- Daily successful payment metrics for last 30 days.
2-- Assumed schema: payments_raw(event_id, payment_id, status, amount_cents, event_time, ingested_at)
3
4with ranked as (
5  select
6    event_id,
7    payment_id,
8    status,
9    amount_cents,
10    cast(event_time as date) as event_date,
11    ingested_at,
12    row_number() over (
13      partition by event_id
14      order by ingested_at desc
15    ) as rn
16  from payments_raw
17  where event_time >= current_date - interval '30' day
18),
19deduped as (
20  select
21    event_id,
22    payment_id,
23    status,
24    amount_cents,
25    event_date
26  from ranked
27  where rn = 1
28)
29select
30  event_date,
31  sum(case when status = 'SUCCEEDED' then amount_cents else 0 end) / 100.0 as success_volume_usd,
32  count(distinct case when status = 'SUCCEEDED' then payment_id end) as distinct_successful_payments
33from deduped
34group by event_date
35order by event_date;

1-- Daily 7-day conversion from START_RETURN to SUBMIT_RETURN.
2-- Assumed schema: tt_funnel_events(user_id, event_name, event_ts)
3
4with starts as (
5  select
6    user_id,
7    event_ts as start_ts,
8    cast(event_ts as date) as start_date
9  from tt_funnel_events
10  where event_name = 'START_RETURN'
11),
12submits as (
13  select
14    user_id,
15    event_ts as submit_ts
16  from tt_funnel_events
17  where event_name = 'SUBMIT_RETURN'
18),
19start_to_submit as (
20  select
21    s.user_id,
22    s.start_date,
23    s.start_ts,
24    min(sub.submit_ts) as first_submit_ts
25  from starts s
26  left join submits sub
27    on sub.user_id = s.user_id
28   and sub.submit_ts >= s.start_ts
29   and sub.submit_ts <  s.start_ts + interval '7' day
30  group by
31    s.user_id,
32    s.start_date,
33    s.start_ts
34)
35select
36  start_date,
37  count(*) as starts,
38  count(case when first_submit_ts is not null then 1 end) as converted_within_7d,
39  (count(case when first_submit_ts is not null then 1 end) * 1.0) / nullif(count(*), 0) as conversion_rate_7d
40from start_to_submit
41group by start_date
42order by start_date;

1from __future__ import annotations
2
3from dataclasses import dataclass
4from datetime import datetime, timezone
5from typing import Any, Dict, Iterable, List, Optional, Tuple
6
7
8@dataclass(frozen=True)
9class Event:
10    account_id: str
11    event_ts: str
12    event_id: str
13
14
15def _parse_iso8601_utc(ts: str) -> Optional[datetime]:
16    """Parse an ISO-8601 timestamp into an aware datetime.
17
18    Accepts timestamps ending with 'Z' or with an explicit offset.
19    Returns None if invalid.
20    """
21    if not isinstance(ts, str) or not ts:
22        return None
23    try:
24        # Handle common 'Z' suffix.
25        if ts.endswith("Z"):
26            ts = ts[:-1] + "+00:00"
27        dt = datetime.fromisoformat(ts)
28        if dt.tzinfo is None:
29            # Treat naive timestamps as invalid in data pipelines.
30            return None
31        return dt.astimezone(timezone.utc)
32    except Exception:
33        return None
34
35
36def latest_event_per_account(
37    records: Iterable[Dict[str, Any]],
38) -> Tuple[Dict[str, Dict[str, str]], int]:
39    """Return latest event per account_id and count of skipped invalid records.
40
41    Latest is defined by max event_ts, tie-break by max event_id (lexicographic).
42    Output values preserve original string fields.
43    """
44    best: Dict[str, Tuple[datetime, str, Dict[str, str]]] = {}
45    skipped = 0
46
47    for r in records:
48        account_id = r.get("account_id")
49        event_ts = r.get("event_ts")
50        event_id = r.get("event_id")
51
52        if not isinstance(account_id, str) or not isinstance(event_id, str):
53            skipped += 1
54            continue
55
56        dt = _parse_iso8601_utc(event_ts)
57        if dt is None:
58            skipped += 1
59            continue
60
61        payload = {
62            "account_id": account_id,
63            "event_ts": str(event_ts),
64            "event_id": event_id,
65        }
66
67        if account_id not in best:
68            best[account_id] = (dt, event_id, payload)
69            continue
70
71        cur_dt, cur_event_id, _ = best[account_id]
72        if (dt > cur_dt) or (dt == cur_dt and event_id > cur_event_id):
73            best[account_id] = (dt, event_id, payload)
74
75    # Strip internal datetime, return only record payloads.
76    result = {k: v[2] for k, v in best.items()}
77    return result, skipped
78
79
80if __name__ == "__main__":
81    sample = [
82        {"account_id": "A", "event_ts": "2025-01-01T10:00:00Z", "event_id": "e1"},
83        {"account_id": "A", "event_ts": "bad-ts", "event_id": "e2"},
84        {"account_id": "A", "event_ts": "2025-01-01T10:00:00Z", "event_id": "e9"},
85        {"account_id": "B", "event_ts": "2024-12-31T23:59:59+00:00", "event_id": "e3"},
86    ]
87    latest, skipped = latest_event_per_account(sample)
88    print(latest)
89    print("skipped=", skipped)
90

1from __future__ import annotations
2
3from collections import defaultdict
4from datetime import date, timedelta
5from typing import DefaultDict, Dict, Iterable, List, Tuple
6
7
8def _parse_day(d: str) -> date:
9    # Expect strict YYYY-MM-DD.
10    y, m, dd = d.split("-")
11    return date(int(y), int(m), int(dd))
12
13
14def rolling_7day_sum_per_user(
15    records: Iterable[Tuple[str, str, float]]
16) -> Dict[str, List[Tuple[str, float]]]:
17    """Compute rolling 7-day sums over observed days per user.
18
19    For each user, output is sorted by day (string), and rolling sum includes amounts
20    on days in [day-6, day]. Missing days contribute 0, but you only emit observed days.
21    """
22    # Aggregate duplicates within a day first.
23    per_user_day: DefaultDict[str, DefaultDict[date, float]] = defaultdict(lambda: defaultdict(float))
24    for user_id, day_str, amount in records:
25        if not isinstance(user_id, str) or not isinstance(day_str, str):
26            continue
27        try:
28            day = _parse_day(day_str)
29        except Exception:
30            continue
31        per_user_day[user_id][day] += float(amount)
32
33    out: Dict[str, List[Tuple[str, float]]] = {}
34
35    for user_id, day_map in per_user_day.items():
36        days = sorted(day_map.keys())
37        res: List[Tuple[str, float]] = []
38
39        left = 0
40        window_sum = 0.0
41
42        for right, d in enumerate(days):
43            window_sum += day_map[d]
44
45            # Maintain window where days[left] >= d - 6
46            cutoff = d - timedelta(days=6)
47            while days[left] < cutoff:
48                window_sum -= day_map[days[left]]
49                left += 1
50
51            res.append((d.isoformat(), window_sum))
52
53        out[user_id] = res
54
55    return out
56
57
58if __name__ == "__main__":
59    sample = [
60        ("u1", "2025-01-01", 10.0),
61        ("u1", "2025-01-03", 5.0),
62        ("u1", "2025-01-08", 2.0),
63        ("u2", "2025-01-01", 7.0),
64        ("u2", "2024-12-31", 1.0),
65    ]
66    print(rolling_7day_sum_per_user(sample))
67

What jumps out isn't any single dominant category. It's that Intuit spreads real weight across pipeline work, system design, SQL, data modeling, and cloud infra, so you can't afford a blind spot in any of them. Pipeline engineering and SQL compound on each other in particularly nasty ways here: a question about building a Kafka-to-Redshift flow for QuickBooks payment events will pivot into writing the exact window-function query that validates correctness downstream, and fumbling the SQL half tanks an otherwise solid architecture answer. Candidates who treat this like a typical loop and pour all their prep hours into Python algorithms (only 5% of the question mix) end up underprepared for the applied, Intuit-product-specific scenarios that dominate the rest.

Practice with financial-data pipeline and modeling scenarios at datainterview.com/questions.

How to Prepare for Intuit Data Engineer Interviews

Intuit's newest product line, the Intuit Enterprise Suite, is an AI-native ERP built for mid-market businesses with industry-specific KPIs and automated workflows. That's a signal worth paying attention to: the company is expanding beyond its traditional small-business and consumer tax base, and data engineers are the ones who have to make QuickBooks transaction schemas, Credit Karma credit profiles, and Mailchimp campaign events all play nicely together inside a single platform. Meanwhile, Trust and Safety has open Staff DE roles focused on fraud detection pipelines for financial transactions, suggesting that's an active investment area.

Most candidates fumble the "why Intuit" question by staying abstract. What separates a strong answer is naming the specific engineering tension you'd be walking into. QuickBooks data feeds directly into IRS reporting for millions of small businesses, so a schema change or duplicate transaction isn't just a bug, it's a compliance event. Yet Intuit's stated mission pushes toward real-time, AI-powered experiences across five distinct product lines, each with different latency and correctness requirements. Frame your answer around that tradeoff, and connect it to their operating values like "Customer Obsession" by explaining how you'd make concrete pipeline design choices (idempotency guarantees, data validation gates) to protect the small business owner downstream.

Try a Real Interview Question

1MERGE INTO dim_customer AS d
2USING (
3  SELECT customer_id, email, status, updated_at
4  FROM (
5    SELECT
6      customer_id,
7      email,
8      status,
9      updated_at,
10      ROW_NUMBER() OVER (
11        PARTITION BY customer_id
12        ORDER BY updated_at DESC
13      ) AS rn
14    FROM stg_customer_changes
15  ) x
16  WHERE rn = 1
17) AS s
18ON d.customer_id = s.customer_id
19WHEN MATCHED AND s.updated_at > d.updated_at THEN
20  UPDATE SET
21    email = s.email,
22    status = s.status,
23    updated_at = s.updated_at
24WHEN NOT MATCHED THEN
25  INSERT (customer_id, email, status, updated_at)
26  VALUES (s.customer_id, s.email, s.status, s.updated_at);

Intuit's technical questions skew applied and domain-grounded. From what candidates report, follow-ups often push on how your solution behaves when QuickBooks transaction records arrive late or when Credit Karma profile data has conflicting fields across sources. Practice similar problems at datainterview.com/coding, focusing on window functions, incremental load logic, and validation scripts that catch financial data anomalies.

Test Your Readiness

Identify your weak spots before the loop with Intuit-focused practice at datainterview.com/questions, especially pipeline design scenarios involving multi-product data flows and regulatory constraints.