Amazon Data Engineer Interview Guide

Most candidates prep for Amazon's BI Engineer role like it's a backend engineering job. It isn't. You'll own everything from Redshift data models to the QuickSight dashboard a VP checks before making inventory decisions, and the interview loop tests that full spectrum.

Amazon Data Engineer Role

After year one, the measure of success is whether stakeholders trust your datasets enough to make decisions without pinging you to verify the numbers. That means your Redshift models are documented, your ETL pipelines have data quality checks that actually catch issues before the Monday metrics review, and you've built enough domain context to proactively flag when a KPI shifts unexpectedly. The role's official title is BI Engineer, and the work skews closer to analytics engineering than pure data plumbing.

A Typical Week

Expect to spend more time investigating metric anomalies and talking to stakeholders than writing new pipeline code. Amazon's two-pizza team structure means no analyst sits between you and the product leader asking why conversion dipped, so your communication skills get tested daily, not just during interviews. Data freshness SLAs and pipeline reliability fall squarely on your shoulders, and on small teams that responsibility concentrates fast.

Projects & Impact Areas

One quarter you might build the dimensional model (slowly changing dimensions included) behind a Marketplace seller performance tracking system that product managers check in QuickSight every morning. Simultaneously, a BIE on an AWS Finance team could be migrating legacy Oracle reporting to Redshift Spectrum queries against S3, slashing costs while improving latency. The common thread: you own ingestion, transformation, metric logic, and the dashboard layer, not just one slice of the stack.

Skills & What's Expected

SQL mastery is the single most underestimated requirement. Candidates over-index on Python algorithms, but interview rounds probe Redshift-specific tuning (sort keys, dist keys, VACUUM), window functions, and query debugging under time pressure. Business acumen is the most underrated skill: interviewers hand you a vague prompt like "how would you measure the health of Subscribe & Save?" and expect you to define KPIs, propose a data model, and articulate tradeoffs. ML knowledge is rated low for this role, though understanding how your curated datasets feed systems like SageMaker may come up depending on the team.

Levels & Career Growth

The widget shows the level bands, but here's the career insight that matters most: the L5-to-L6 jump is where the promotion path narrows, and the blocker is almost always influence scope. At L5 you own your team's datasets reliably; L6 demands cross-team metric governance and evidence that your data products changed how an org makes decisions. Also worth knowing: Amazon's leveling tends to run lower than peer companies, so compare total compensation rather than title when evaluating offers.

Work Culture

Amazon's Leadership Principles aren't wall art. "Dive Deep" and "Ownership" are the literal rubric on your performance review, and they shape the BIE experience more than any technology choice. Frugality is genuine: justifying your Redshift cluster spend shows up in performance goals, and pipeline cost optimization is a real metric your manager tracks. Work arrangement details (remote, hybrid, in-office) vary by org and location, so confirm the policy for your specific team during the recruiter screen.

Amazon Data Engineer Compensation

Amazon's Data Engineer roles often carry Business Intelligence Engineer titles (BIE I through Senior Principal BIE), so don't be confused when your offer letter doesn't say "Data Engineer." The RSU vesting schedule is commonly described as 5/15/40/40 over four years, though Amazon doesn't publish this officially and your offer terms may vary. Sign-on bonuses paid across Years 1 and 2 are designed to bridge the gap, but from what candidates report, the front-loaded cash still doesn't fully match the back-loaded equity, creating a real incentive to stay through Year 3.

Your single biggest lever in negotiation is the sign-on bonus, specifically the Year 1 and Year 2 cash amounts. Amazon's base salary bands are rigid at each level, and RSU grants move only modestly without a competing offer. Frame your counter around total first-year cash (base + sign-on + vested equity) rather than annualized total comp, because that's the number where the gap bites and where recruiters at Amazon have the most flexibility to adjust.

Amazon Data Engineer Interview Process

Weak Leadership Principle stories are among the most common reasons candidates get rejected, right alongside insufficient SQL depth and poor system design. From what candidates report, vague STAR answers without quantified results hurt just as badly as a botched Redshift schema question. Every interviewer scores you against specific LPs, so a single round with thin behavioral examples drags down your entire debrief scorecard.

After your loop wraps, each interviewer writes independent feedback before seeing anyone else's notes. The Bar Raiser, an experienced Amazonian pulled from a completely different org with zero incentive to fill the headcount, carries outsized influence in that debrief. Their role is to protect Amazon's hiring bar, not to help a team staff up, which means a strong Bar Raiser objection can override enthusiasm from the rest of the panel. Prep for that round by mapping at least two detailed STAR stories to each of the top LPs (Customer Obsession, Ownership, Dive Deep, Bias for Action, Earn Trust) with real metrics from your past work.

Amazon Data Engineer Interview Questions

1WITH item_rollup AS (
2  SELECT
3    oi.order_id,
4    SUM(oi.qty) AS total_units
5  FROM order_items oi
6  GROUP BY oi.order_id
7), ranked_orders AS (
8  SELECT
9    o.customer_id,
10    o.order_id,
11    o.order_ts,
12    o.order_total,
13    COALESCE(ir.total_units, 0) AS total_units,
14    ROW_NUMBER() OVER (
15      PARTITION BY o.customer_id
16      ORDER BY o.order_ts DESC, o.order_total DESC, o.order_id DESC
17    ) AS rn
18  FROM orders o
19  LEFT JOIN item_rollup ir
20    ON ir.order_id = o.order_id
21  WHERE o.order_status <> 'CANCELED'
22)
23SELECT
24  customer_id,
25  order_id,
26  order_ts,
27  order_total,
28  total_units
29FROM ranked_orders
30WHERE rn = 1;

1WITH order_ship_date AS (
2  -- Reduce shipments to one row per order so order_total cannot fan out.
3  -- Business assumption: an order is considered "shipped" on its earliest shipped_ts.
4  SELECT
5    s.order_id,
6    CAST(MIN(s.shipped_ts) AS DATE) AS ship_date
7  FROM shipments s
8  GROUP BY s.order_id
9), shipped_orders AS (
10  SELECT
11    o.order_id,
12    osd.ship_date,
13    o.order_total
14  FROM orders o
15  JOIN order_ship_date osd
16    ON osd.order_id = o.order_id
17)
18SELECT
19  ship_date,
20  SUM(order_total) AS shipped_gmv
21FROM shipped_orders
22GROUP BY ship_date
23ORDER BY ship_date;
24
25-- Note: shipment_events is intentionally not joined.
26-- If you must filter to "delivered" or similar, pre-aggregate shipment_events to one row per shipment_id
27-- (for example, MAX(CASE WHEN event_type = 'DELIVERED' THEN 1 END)) before joining to shipments.

1import json
2from datetime import datetime
3from typing import Iterable, List, Dict, Any, Tuple
4
5
6def _parse_time(ts: str) -> datetime:
7    """Parse ISO-8601 timestamps, supporting a trailing 'Z'."""
8    if ts.endswith("Z"):
9        ts = ts[:-1] + "+00:00"
10    return datetime.fromisoformat(ts)
11
12
13def first_event_per_order(lines: Iterable[str]) -> List[Dict[str, Any]]:
14    """Return earliest event per order_id, tie broken by smallest status.
15
16    Each input line is a JSON object with keys: order_id, event_time, status.
17    Output is a list of the selected JSON dicts (original fields preserved).
18    """
19    best: Dict[str, Tuple[datetime, str, Dict[str, Any]]] = {}
20
21    for line in lines:
22        line = line.strip()
23        if not line:
24            continue
25        rec = json.loads(line)
26        oid = rec["order_id"]
27        t = _parse_time(rec["event_time"])
28        status = rec["status"]
29
30        if oid not in best:
31            best[oid] = (t, status, rec)
32            continue
33
34        bt, bs, _ = best[oid]
35        # Earlier timestamp wins; if equal timestamp, lexicographically smaller status wins.
36        if t < bt or (t == bt and status < bs):
37            best[oid] = (t, status, rec)
38
39    # Return just the chosen records.
40    return [triple[2] for triple in best.values()]
41
42
43if __name__ == "__main__":
44    sample = [
45        '{"order_id":"A1","event_time":"2024-01-01T00:00:00Z","status":"SHIPPED"}',
46        '{"order_id":"A1","event_time":"2024-01-01T00:00:00Z","status":"CREATED"}',
47        '{"order_id":"A2","event_time":"2024-01-02T03:00:00+00:00","status":"CREATED"}',
48        '{"order_id":"A1","event_time":"2024-01-01T00:01:00Z","status":"DELIVERED"}',
49    ]
50    out = first_event_per_order(sample)
51    # For A1, timestamps tie, so CREATED wins.
52    print(sorted(out, key=lambda r: r["order_id"]))
53

1from __future__ import annotations
2
3from datetime import datetime, timedelta
4from typing import Iterable, List, Tuple, Dict, Set
5import heapq
6
7
8def _parse_time(ts: str) -> datetime:
9    """Parse ISO-8601 timestamps, supporting a trailing 'Z'."""
10    if ts.endswith("Z"):
11        ts = ts[:-1] + "+00:00"
12    return datetime.fromisoformat(ts)
13
14
15def top_k_asins_unique_customers_last_24h(
16    events: Iterable[Tuple[str, str, str]],
17    ts_now: str,
18    k: int,
19) -> List[Tuple[str, int]]:
20    """Return top K (asin, unique_customer_count) in the last 24h window.
21
22    events: iterable of (asin, customer_id, ts) where ts is ISO-8601 string.
23    ts_now: window reference time (ISO-8601).
24    k: number of ASINs to return.
25
26    Ties are broken by ASIN lexicographic order (stable, deterministic output).
27    """
28    now = _parse_time(ts_now)
29    start = now - timedelta(hours=24)
30
31    # Deduplicate by (asin, customer_id) within the window.
32    # If events are huge, you would partition by asin or approximate, but here keep it exact.
33    seen_pairs: Set[Tuple[str, str]] = set()
34    customers_by_asin: Dict[str, Set[str]] = {}
35
36    for asin, customer_id, ts in events:
37        t = _parse_time(ts)
38        if t < start or t > now:
39            continue
40        pair = (asin, customer_id)
41        if pair in seen_pairs:
42            continue
43        seen_pairs.add(pair)
44        customers_by_asin.setdefault(asin, set()).add(customer_id)
45
46    # Build counts.
47    counts: List[Tuple[int, str]] = []
48    for asin, custs in customers_by_asin.items():
49        counts.append((len(custs), asin))
50
51    if k <= 0:
52        return []
53
54    # Get top K by count desc, then asin asc.
55    # heapq.nlargest uses the tuple ordering, so use (count, -) carefully.
56    top = heapq.nlargest(k, counts, key=lambda x: (x[0], -ord(x[1][0]) if x[1] else 0))
57
58    # The key above is not a correct general lexicographic tiebreak, so do it explicitly.
59    # Sort all candidates by (-count, asin) and slice K. This is acceptable for moderate cardinality.
60    top_sorted = sorted(((asin, cnt) for cnt, asin in counts), key=lambda p: (-p[1], p[0]))
61    return top_sorted[:k]
62
63
64if __name__ == "__main__":
65    data = [
66        ("B001", "C1", "2024-01-02T00:00:00Z"),
67        ("B001", "C1", "2024-01-02T00:01:00Z"),  # duplicate customer for same ASIN
68        ("B001", "C2", "2024-01-02T01:00:00Z"),
69        ("B002", "C3", "2024-01-01T02:00:00Z"),
70        ("B003", "C4", "2023-12-31T00:00:00Z"),  # out of window
71    ]
72    print(top_k_asins_unique_customers_last_24h(data, "2024-01-02T02:00:00Z", 2))
73

Amazon's loop is structured so that pipeline design and AWS infrastructure questions feed off each other in the same interview day, and candidates who prep them in isolation get exposed when a Bar Raiser or system design interviewer asks them to walk through a real scenario end-to-end (say, rebuilding the ingestion layer for seller performance metrics on the marketplace). The compounding difficulty isn't just topical overlap; it's that Amazon interviewers frame every prompt around a specific business domain like fulfillment forecasting or ad attribution, so generic "I'd use Spark and S3" answers without connecting to how that data actually flows through Amazon's ecosystem score poorly on the Ownership and Dive Deep LPs. The single biggest prep mistake? Treating Python algorithms as the main technical hurdle when the real gate is the combined weight of SQL, data modeling, and Redshift/OLAP engineering, three distinct areas that all demand you reason about physical warehouse design choices under Amazon-scale constraints.

Practice Amazon-style questions across all six areas at datainterview.com/questions.

How to Prepare for Amazon Data Engineer Interviews

Amazon reported $717 billion in revenue last year, and the company's current priorities read like a Data Engineering hiring brief. AWS is racing to make AI inference cheaper through custom chips and purpose-built infrastructure, Ads is wiring up AI-powered campaign optimization with unified audience views across streaming and display, and Stores just pushed same-day pharmacy delivery to nearly 4,500 cities.

Each of those bets demands pipelines, warehouse schemas, and real-time data flows that don't exist yet. Before your loop, ask your recruiter which segment you're interviewing for so you can speak to its specific data problems, not Amazon's mission statement in the abstract.

Your "why Amazon" answer needs to name the exact LP you'll demonstrate, then prove it with a story that could only come from your experience. Don't just say "Ownership." Describe how you owned a pipeline's on-call rotation, caught a data quality regression during a weekly business review, and communicated the root cause to a non-technical stakeholder before they had to ask. That mirrors how Amazon's Leadership Principles actually function as the scoring rubric in behavioral and Bar Raiser rounds, where interviewers are trained to probe for specifics like SLA ownership and cross-team influence rather than enthusiasm about working at scale.

Try a Real Interview Question

1WITH filtered AS (
2  SELECT
3    marketplace_id,
4    category,
5    CAST(revenue AS DECIMAL(18,2)) AS revenue
6  FROM category_daily_revenue
7  WHERE order_date >= DATE '2024-01-01'
8    AND order_date <= DATE '2024-01-07'
9),
10agg AS (
11  SELECT
12    marketplace_id,
13    category,
14    SUM(revenue) AS revenue_7d
15  FROM filtered
16  GROUP BY marketplace_id, category
17),
18totals AS (
19  SELECT
20    marketplace_id,
21    SUM(revenue_7d) AS total_revenue_7d
22  FROM agg
23  GROUP BY marketplace_id
24),
25ranked AS (
26  SELECT
27    a.marketplace_id,
28    a.category,
29    a.revenue_7d,
30    t.total_revenue_7d,
31    CASE
32      WHEN t.total_revenue_7d = 0 THEN 0
33      ELSE a.revenue_7d / t.total_revenue_7d
34    END AS revenue_share,
35    DENSE_RANK() OVER (
36      PARTITION BY a.marketplace_id
37      ORDER BY a.revenue_7d DESC, a.category ASC
38    ) AS rank
39  FROM agg a
40  JOIN totals t
41    ON a.marketplace_id = t.marketplace_id
42)
43SELECT
44  marketplace_id,
45  category,
46  revenue_7d,
47  total_revenue_7d,
48  revenue_share,
49  rank
50FROM ranked
51WHERE rank <= 2
52ORDER BY marketplace_id, rank, category;

Amazon's coding rounds from what candidates report lean toward business-flavored data manipulation (think: parsing seller transaction logs or aggregating ad attribution events) rather than graph theory or dynamic programming. The interviewers want to see you handle messy, real-world inputs the way you'd handle a production ETL edge case. Practice similar scenarios at datainterview.com/coding, paying special attention to problems that require you to clean and reshape data before computing a result.

Test Your Readiness

Amazon's two dedicated SQL rounds go deep on Redshift-specific tuning (sort keys, dist keys, VACUUM) and window functions for business metrics. Pressure-test those skills at datainterview.com/questions so you discover gaps while you can still close them.