Lyft Data Scientist (Entry Level) - Comprehensive Interview Preparation Guide

Core services
I would build a platform with a job API, scheduler, quota service, checkpoint store, metadata catalog, and node agents. The scheduler matches jobs to GPU pools, while the quota service enforces team budgets and priorities.

How jobs get compute
A team submits a job spec with requested GPUs, runtime, and a checkpoint policy. The scheduler grants a lease, which is a time-bounded claim on nodes. Workers heartbeat to renew the lease. On completion, failure, or preemption, the lease ends and the GPUs are released automatically.

Controls

• Per-team quotas and project budgets
• Priority classes for urgent training
• Spot first scheduling with fallback to on-demand
• Mandatory checkpoints for long jobs
• Admission control when the cluster is full

Worked example
A 64-GPU run might get 8 workers with 8 GPUs each and a 30-minute renewable lease. If a node fails, the job restarts from the last checkpoint instead of starting over.

This design keeps cost visible, failures recoverable, and shared capacity fair.

Direct answer

In a marketplace with constrained supply, I would charge the demand side a visible service fee and keep the supply side's commission low (or subsidise it, meaning charge it less than it is worth, even below cost, to keep it on the platform), because supply is the scarce, hard-to-replace side and demand will follow it. I would set the overall take rate (take rate = platform revenue divided by GMV, where GMV is gross merchandise value, the total value of transactions) at the level that maximises contribution (revenue minus the variable cost of serving it) after accounting for users trading off-platform to dodge fees, starting lower while supply is thin, and I would keep both sides balanced with fill-rate-driven dynamic pricing (prices that move with live supply and demand) instead of blanket discounts.

Which side to subsidise

Rules of thumb for two-sided pricing, applied here:

• Subsidise the side whose presence creates more value for the other side and who is more price-sensitive. When supply is the bottleneck, each extra provider is worth a lot to demand, and a provider who earns too little leaves.
• Charge the side that gains most from the match and is less price-sensitive, usually buyers, who also see the fee as part of a purchase.
• Do not subsidise the abundant side. Giving discounts to demand when supply is full creates unfilled requests and a bad first experience, which damages the next visit.

Illustrative example: a home-services marketplace with a $50 average booking. Demand is plentiful; providers are limited and can accept work elsewhere.

Setting the take rate

Per completed booking: GMV $50, cost to serve $2.50 (the platform's own cost of handling one booking: payments, support, insurance). Leakage is the share of bookings taken off-platform to avoid the fee. Assume (illustrative, to be replaced with measurement) leakage of 2% at fees up to 10%, rising by 60 times the square of the excess above 10%. Contribution per booking = 50 x take x (1 - leakage) - 2.50 x (1 - leakage).

Worked check at 15%: leakage = 0.02 + 60 x (0.05)^2 = 0.17; revenue 50 x 0.15 = $7.50, times 0.83 = $6.225; cost $2.50 x 0.83 = $2.075; contribution $4.15.

On these made-up numbers contribution peaks near 15% (a finer search puts the exact maximum at about 16%, $4.20 per booking, so the peak is flat between 15% and 17%). Why a squared term: it is a deliberately simple stand-in for a pattern where small fees barely change behaviour while each further point pushes more users to go around the platform than the last, so the loss accelerates. At 12% (2 points over the threshold) leakage adds 60 x 0.02^2 = 2.4 points; at 20% (10 points over) it adds 60 x 0.10^2 = 60 points. A straight line cannot produce that acceleration. The 10% threshold and the 60 are invented, so real curves must be measured; the table shows why a maximum exists, not where yours is.

The model leaves out provider churn: higher fees push providers away and supply is the constraint. So I would launch near 12%, below the modelled optimum, and move up in dense markets once supply is healthy and measured leakage and provider retention justify it. The shape (revenue rises, then leakage erodes it) is the lesson, not these numbers.

Ways to reduce leakage without lowering price: a take rate that falls with repeat bookings between the same pair, payment protection and insurance only available on-platform, and scheduling and reviews that lose value off-platform.

Keeping supply and demand balanced

Monitor fill rate (share of requests that get matched), time to match, provider utilisation (booked share of available hours) and provider earnings per hour. Then respond:

• Fill rate low, utilisation high: raise demand-side fees at peak times (dynamic pricing), or pay providers bonuses for peak slots, and recruit supply.
• Utilisation low, fill rate high: demand is thin, so spend on demand promotions or lower demand fees in that market.
• Different markets get different fees: thin new markets get subsidies; mature ones get higher take.

Implementation notes

Keep fee rules as per-market configuration, record each fee on the transaction ledger (the platform's record of every money movement), and support split payments (one customer payment divided between provider and platform, with the provider's payout net of fee and held until the job completes) so experiments and audits are possible.

Pitfalls

• Optimising short-term take rate and ignoring supply churn.
• Treating the supply and demand fees as independent: raising one changes behaviour of both.
• Copying another marketplace's fee. Their supply conditions differ.

Direct answer

You need a battery, not a single test, because "disparate impact" spans multiple metrics (selection rate, TPR, FPR, PPV) and multiple subgroups of very different sizes, and testing many subgroups at once inflates false positives. The core building blocks are: per-subgroup proportion tests (or Fisher's exact for tiny cells) against a reference group, effect-size reporting (risk difference and Cohen's h) so statistical significance never gets confused with practical significance, confidence intervals sized correctly for unequal N, and Benjamini-Hochberg FDR control across the whole battery of subgroup-metric tests.

Structured elaboration

Start here: for most cells, a two-proportion z-test against the reference group plus Benjamini-Hochberg correction across the battery is enough. The rest below, Fisher's exact, Wilson intervals, Cohen's h, and Benjamini-Yekutieli, are what you reach for once specific cells get small or metrics turn out to be correlated; treat them as depth to mention, not the first tools you pick up.

1. Define the metrics and the comparison structure

• Primary metrics: selection rate / positive prediction rate (demographic parity), true positive rate (equal opportunity), false positive rate, positive predictive value.
• Build one 2x2 table per (subgroup, metric) pair: subgroup vs. reference group.
• Include intersectional cells (e.g. race x gender), but pre-register a minimum cell size N_min (commonly 50) below which a cell is reported descriptively only, not tested. Testing tiny cells either has no power or produces unstable estimates.

2. Pick the test per cell based on size

3. Effect size, not just p-value

Cohen's h is the standard effect size for comparing two proportions:

Conventionally, |h| below 0.2 is a small effect, 0.2 to 0.5 medium, above 0.5 large. Report h alongside the risk difference

because with a large enough N a test can flag a half-percentage-point RD as "significant" even though it is operationally meaningless. Flag on effect size AND significance, never significance alone.

4. Confidence intervals under unequal N

For the risk difference between subgroup and reference, use the unpooled standard error (the pooled SE is only for the significance test's null variance, not for the CI):

Unequal N shows up directly here: a small subgroup gets a much wider interval for the same point estimate, which is exactly the signal a reviewer needs before escalating a finding from a 50-person cell.

5. Multiplicity: Benjamini-Hochberg across the whole battery

With G subgroups times M metrics you run G x M tests. Controlling each at alpha = 0.05 individually lets the family-wise chance of at least one false flag climb far above 5%. Sort p-values ascending and flag every rank k up to the largest k such that

for a target FDR q (commonly 0.05). BH controls the expected proportion of false discoveries among flagged subgroups, which is the right target here: you would rather occasionally re-check a false flag than let a real disparity through because of an overly strict Bonferroni bar.

6. Reporting

One row per (subgroup, metric): N, RD, 95% CI, Cohen's h, raw p-value, BH q-value, flagged yes/no. Pair the statistical layer with a predefined practical-significance threshold (for example RD > 0.03 or |h| > 0.2) so a statistically significant but practically trivial row doesn't consume review bandwidth.

Worked example

Reference group: n0 = 8000, x0 = 2400, so p0 = 2400/8000 = 0.3000. Testing 5 subgroups against that reference on the same metric (selection rate):

(z-test uses pooled SE for the test statistic and normal approximation for the p-value; RD confidence intervals use the unpooled SE formula above.)

Applying BH at q = 0.05 across these 5 tests: sorted p-values are 0.00039, 0.00799, 0.01019, 0.01269, 0.12377, compared against thresholds (k/5) x 0.05 = 0.01, 0.02, 0.03, 0.04, 0.05. Ranks 1 through 4 clear their thresholds, so G1, G2, G3, and G4 are flagged, with BH q-values 0.00195, 0.01586, 0.01586, and 0.01586 respectively; G5's q-value is 0.12377, so it is not flagged.

The instructive part: G3 and G5 have the identical point effect (RD = -0.10, h = -0.232), but only G3 survives correction. G5's 50-person sample is too small to distinguish that effect from noise; its CI, [-0.2113, 0.0113], still straddles zero. This is why sample-size-aware confidence intervals matter more than the raw effect size when deciding whether to escalate a subgroup finding or flag it as underpowered and needing more data.

Trade-offs and pitfalls

• BH assumes tests are independent or positively dependent (PRDS, positive regression dependency: roughly, the tests are never negatively correlated with each other). If subgroup metrics are heavily correlated (testing PPR and TPR for the same subgroup are not independent), consider Benjamini-Yekutieli, which is more conservative but valid under arbitrary dependence.
• The z-test and Wald-style CI are unreliable below roughly n = 30 or when p is near 0 or 1. Defaulting to Fisher's exact and Wilson intervals for every small cell avoids a class of "false disparity" flags caused purely by asymptotic breakdown.
• A common wrong turn: running every test unadjusted and hand-picking the "interesting" flagged subgroups for a report. That is p-hacking with extra steps. Pre-register the full battery, all metrics times all subgroups down to N_min, before looking at results.
• Unadjusted and covariate-adjusted parity can disagree: a raw PPR gap may shrink or reverse after adjusting for a legitimate business covariate. Report both, and be explicit that "adjusted for X" is itself a judgment call about which covariates are legitimate business factors versus proxies for the protected attribute.
• Intersectional cells lose power fastest as cell counts shrink multiplicatively. Prefer a hierarchical, partial-pooling model across intersectional cells over running dozens of underpowered pairwise tests once N_min filtering starts discarding most of the intersectional signal.

Direct answer

The underlying finding stays identical, but you change altitude, vocabulary, and level of supporting detail. An executive gets the headline, the business impact, and the recommended decision in one or two lines up front. The implementation team gets the mechanism, the caveats, and enough of the underlying data to act on it correctly.

Structured elaboration

• Altitude: conclusion-first for the executive, versus enough method detail for the team to trust and reproduce the diagnosis.
• Vocabulary: business-impact language (revenue, risk, timeline) for the executive, technical specifics (segments, funnels, thresholds) for the team.
• Format: a one-slide or one-paragraph summary versus a working document with a data appendix.
• What must never change: the number itself and the direction of the conclusion, in both versions.

Worked example

Finding: onboarding drop-off at step 3 is costing an estimated 6% of new signups per month.
Executive version: "we're losing about 6 of every 100 new signups at the step-3 confirmation screen, fixing it could recover meaningful revenue this quarter, recommend prioritizing it."
Team version: "62% of that drop-off happens on mobile between form submit and confirmation render, median time to abandon is 9 seconds, this looks like a loading-state issue on mobile specifically."
Both versions agree on the 6% headline number and the recommendation to prioritize the fix.

Trade-offs and pitfalls

The two versions can quietly drift into different conclusions if you're not careful, always trace both back to the same underlying analysis. Over-simplifying for the executive can also strip out the one caveat that would have changed their decision, so pick what to omit deliberately, not by default.

What the interviewer probes next

Expect a question about what happens when the executive summary gets forwarded on without you in the room, and how you prevent it from being read out of context.

Direct answer

I treat two weeks as a research spike with a decision at the end, not open-ended learning time. I spend it testing the vendor's own specific claims against a real slice of our workload in an isolated trial that can't touch production, and I decide in advance what result would make me say no, so the verdict isn't a last-minute gut call.

Structured elaboration

• Find the two or three claims that actually gate the decision. I don't try to become an expert in the whole component. I identify the handful of things that, if false, would kill the decision (does it handle our real data volume, is it compatible with what we already depend on, does its failure behavior make sense), and I aim the whole two weeks at testing those.
• Test the claims myself instead of trusting the documentation. Vendor docs and marketing describe the happy path. I build the smallest thing that proves or disproves the specific claim using our own representative data or traffic shape, not the vendor's demo dataset.
• Keep the trial isolated with a clear way back out. The evaluation runs in a sandbox or a feature-flagged path (gated behind a feature flag, a toggle that turns a new component on for only a slice of traffic, without needing a separate deploy to turn it back off) that can't reach real customer data, and I know before I start how quickly we could rip it back out if it doesn't work, so trying it never becomes a one-way door.
• Decide the "say no" triggers before I see the results, not after. Examples: it fails under our expected traffic at even a modest multiple, there's no realistic exit path if we need to remove it later, or its security posture doesn't clear a bar we've already set. Deciding this in advance keeps the deadline from quietly lowering the bar.
• Under a genuinely compressed timeline this same shape compresses further. If instead of two weeks I had days, for instance needing to understand and counter an unfamiliar type of threat quickly, I'd skip the exploratory tour entirely and go straight at the one or two claims that actually gate whether we're safe, using whatever cheap check answers that fastest.
• Write the finding down either way. A short adoption note (what I tested, what passed, what didn't, the verdict) means the next person evaluating something similar doesn't redo this from scratch.
• If we adopt it, the first real use is staged, not a big rollout. A small, reversible slice of production traffic with its own explicit checks, expanded only once that holds up.

Worked example

A team I was on had two weeks to decide whether to adopt a third-party message-queuing service for a path that mattered a lot, with thin documentation and nobody on the team who'd used it in production. Instead of reading everything, I picked out the two claims that actually mattered to us: that it could sustain our peak message rate, and that we could get our data back out cleanly if we ever needed to leave. I spent the first three days building a minimal proof of concept against a sandbox account, fed it a replay of a real day's traffic rather than a toy example, and it held up. I spent a day specifically testing the export path, since a dead end there was one of my pre-agreed reasons to say no, and it worked cleanly. With about five days left I wrote up a one-page recommendation with what I'd tested, what I hadn't had time to test, and the specific evidence behind each claim, and we adopted it behind a feature flag on a low-traffic queue first, with its own success checks, before moving anything critical onto it.

Trade-offs and pitfalls

The biggest trap is spending the whole window reading and exploring instead of testing the load-bearing claims, which leaves you with broad but shallow familiarity and no real evidence at decision time. The opposite trap, trusting the vendor's claims at face value because the deadline is tight, is worse: it just moves the real evaluation to production, after you've already committed. Testing directly against live systems instead of an isolated trial is the other classic mistake, since it turns an evaluation into an incident risk. And skipping the write-up because the deadline already felt tight just guarantees the next evaluator repeats your work.

Direct answer

Keep alignment across time zones with three levers: shrink what actually needs real-time overlap by defaulting to async updates on a fixed template, protect a small deliberately scheduled overlap window for anything that truly needs live discussion, and make handoffs explicit in writing so context transfers cleanly across the boundary instead of depending on someone's memory.

Framework

Reduce dependence on overlap. Default to async status updates on a fixed cadence, and use written decision docs rather than requiring a live meeting for every decision. Most updates don't need a room, only genuinely ambiguous or high-stakes calls do.

Protect a deliberate overlap window. Negotiate a recurring block, even a short one, and rotate who takes the inconvenient time so the burden doesn't always fall on the same region.

Make handoffs explicit. When work crosses a time-zone boundary, produce a short written artifact rather than relying on a quick chat message. This matters most in ops-heavy, always-on contexts.

Worked example

Consider an on-call rotation providing 24/7 production coverage across three time zones (for example [Region A], [Region B], and [Region C]), where the two outer regions have little or no live overlap with each other.

• Shadow and overlap periods: the incoming region's on-call shadows the outgoing region's on-call for a short deliberate window at the shift boundary, even 15 to 30 minutes, to ask questions live before the outgoing engineer signs off.
• Written handoff template: a standard document filled at every handoff covering open incidents, any systems in a degraded state, changes deployed in the last shift, and explicit 'known risk' or 'do not touch' notes.
• Escalation expectations: a written policy defining what counts as page-worthy versus a handoff note, who the secondary on-call is in each region, and how long the incoming engineer has to acknowledge before it auto-escalates.
  Result: even with zero live overlap between two of the three regions, the written handoff plus the short shadow window from the middle region means each incoming on-call starts already briefed, instead of reconstructing state from raw logs.
  For non-ops roles the same mechanism applies with a different artifact, for example a design or product handoff might be a written decision log plus a recorded walkthrough rather than an incident handoff, but the principle (explicit written handoff over a live conversation) is the same.

Trade-offs and pitfalls

• Repeatedly scheduling occasional syncs at painful hours burns out whichever time zone draws the short straw. Rotate it deliberately.
• Async-only breaks down for genuinely ambiguous or high-stakes decisions. Some live channel for true emergencies still has to exist.
• A handoff template that's too heavy gets skipped under time pressure. Keep it short enough to fill in within a few minutes.
• Assuming a chat message counts as a handoff is the actual failure mode this whole approach is designed to prevent. The structured artifact is the point, not the tool it's written in.

Direct answer
Precise wording matters because a reader acts on what the words literally say, not on what the writer meant; vague or ambiguous phrasing lets each reader fill in the gap with their own assumption, and those assumptions frequently disagree.

Structured elaboration

• Ambiguity creates silent forks in understanding. Two readers of the same imprecise sentence can each walk away confident they understood it, while holding two different, incompatible interpretations, and neither realizes there's a disagreement until it surfaces later, usually at a worse time.
• Vague quantifiers are a common culprit: words like "soon," "significant," or "most" mean different things to different readers and different things in different contexts.
• Precision does not mean verbosity. A precise sentence can be shorter than a vague one; "by Thursday 5pm" is both more precise and no longer than "soon."
• To enforce more precise terminology: agree on and write down a small shared glossary for terms that get used loosely (what counts as "done," what "urgent" means for this team), review drafts specifically looking for vague quantifiers and ambiguous pronouns ("it," "this") whose referent isn't obvious, and normalize asking "what do you mean by X specifically?" in review rather than letting it pass.

Worked example
Imprecise: "We'll ship the fix soon, once we've done a bit more testing."

What actually happened: one stakeholder read "soon" as "later today" and told a customer to expect it that day; the engineering team read it as "sometime this week" because "a bit more testing" meant a multi-day regression pass. The customer was told an incorrect date because two people read the same sentence and reasonably reached different conclusions.

Precise version: "We'll ship the fix by end of day Thursday, pending a two-day regression test that starts tomorrow."

Same information, but now both readers have the same understanding, and if the regression test finds something, "Thursday" is a concrete promise that either holds or needs an explicit update, rather than a vague one that quietly slips.

Trade-offs and pitfalls

• Being maximally precise about everything is exhausting and unnecessary for low-stakes communication; reserve the rigor for statements other people will act on or make commitments based on.
• Precision can be used dishonestly too, to sound more certain than you actually are; if you genuinely don't know the date, the honest and still precise move is "I don't have a firm date yet, I'll confirm by Wednesday," not a confident-sounding guess.
• Enforcing a shared glossary only works if it's actually referenced in practice, not just written once and forgotten; it needs to show up in review habits, not just documentation.

Approach

list(orig) is a shallow copy: it allocates a new outer list, but every element it holds is the exact same dict object as in orig, so mutating something inside one of those shared dicts (like the list stored under 'a') is visible through both orig and sh. copy.deepcopy(orig) recursively duplicates the dicts and the lists inside them, so dp shares nothing with orig at any level and is unaffected by mutating orig's nested state.

Code (Python 3.12)

import copy

orig = [{'a': [1, 2]}, {'b': [3]}]
sh = list(orig)
dp = copy.deepcopy(orig)

orig[0]['a'].append(99)   # mutate the nested list two levels deep

print("orig:", orig)
print("sh:  ", sh)
print("dp:  ", dp)
print("sh[0] is orig[0]:", sh[0] is orig[0])
print("dp[0] is orig[0]:", dp[0] is orig[0])

Output:

orig: [{'a': [1, 2, 99]}, {'b': [3]}]
sh:   [{'a': [1, 2, 99]}, {'b': [3]}]
dp:   [{'a': [1, 2]}, {'b': [3]}]
sh[0] is orig[0]: True
dp[0] is orig[0]: False

Trace through both

sh = list(orig): a new list object is created for sh, but sh[0] is literally orig[0], the same dict, and sh[1] is literally orig[1]. orig[0]['a'] is a list object nested inside that shared dict, so sh[0]['a'] is that same list too, three references deep (orig[0]['a'], sh[0]['a'], and the object itself are all one thing). Calling .append(99) mutates that one shared list in place, so the change is visible through orig, sh, or any other name bound to the same dict, because nothing about list(orig) ever touched anything below the outer list.

dp = copy.deepcopy(orig): deepcopy walks into orig, sees it is a list, creates a new list, then for each element (a dict) creates a new dict, then for each value inside that dict (a list) creates a new list too, copying [1, 2]'s contents into a brand-new list object. By the time orig[0]['a'].append(99) runs, dp[0]['a'] is an entirely separate list from orig[0]['a'], so the mutation has nowhere to propagate to.

Key points

• The depth of sharing in a shallow copy is exactly one level: the container is new, its immediate contents are shared. list(orig), orig.copy(), orig[:], and copy.copy(orig) all produce the same one-level-shallow result for a plain list.
• deepcopy uses an internal memo dictionary keyed by id() to avoid copying the same shared object twice or infinitely recursing on cyclic structures; that memoization is also why two elements of orig that happen to reference the same nested object stay correctly linked to each other in the deep copy, rather than becoming two independent copies that have drifted apart.

Complexity and edge cases

list(orig) is $O(k)$ where $k$ is the number of top-level elements (just copying references). copy.deepcopy(orig) is $O(n)$ where $n$ is the total number of objects in the entire nested structure, since every one of them gets visited and duplicated.

• If orig[0] and orig[1] both referenced the same inner dict object (not the case in this example, but a common real bug), a shallow copy would obviously still share it; a deep copy would still correctly produce two shallow-copy targets that both point to one newly-copied dict, preserving the original aliasing relationship rather than accidentally splitting a shared object into two independent ones.
• Tuples, sets, and custom objects nested inside the structure are handled by deepcopy too (it dispatches on type, and respects a class's own __deepcopy__ if one is defined); list(orig)-style shallow copying has no equivalent generalization beyond "copy this one container".

ROLLUP produces a hierarchy of subtotals in one query: detail rows, then progressively higher-level subtotals, culminating in a grand total, all without running separate GROUP BY queries and UNIONing them together.

Structured elaboration

SELECT date, region, SUM(amount) AS total
FROM sales
GROUP BY ROLLUP(date, region);

ROLLUP(date, region) produces, in one pass: detail rows grouped by (date, region), then subtotal rows grouped by date alone (with region shown as NULL), then a single grand-total row (with both date and region shown as NULL). The NULLs appearing in the grouping columns of a ROLLUP result are not missing data, they specifically mean "this row is a subtotal or total across all values of this column", a signal you can detect and label using GROUPING(). But ROLLUP is a strict, nested hierarchy in the order its arguments are listed: ROLLUP(date, region) only ever collapses region into date-level subtotals, it never independently collapses date to produce a region-only subtotal, because a by-region subtotal isn't one of the levels the date-then-region hierarchy passes through. Since the question asks for subtotals by date AND by region AND a grand total, three genuinely independent subtotal shapes, plain ROLLUP can't produce all three; GROUPING SETS is the tool for that, since it lets you list each grouping combination independently instead of only a nested hierarchy:

SELECT date, region, SUM(amount) AS total
FROM sales
GROUP BY GROUPING SETS ((date, region), (date), (region), ());

Each parenthesized item in GROUPING SETS is its own independent grouping: (date, region) for the detail rows, (date) for date-only subtotals, (region) for region-only subtotals, and () for the grand total, all four computed in one pass and combined into one result.

Worked example

Given sales(date, region, product, amount) with two rows on 2025-01-01 (east: 100, west: 50) and one row on 2025-01-02 (east: 30): ROLLUP(date, region) produces the 3 detail rows, plus a subtotal for 2025-01-01 (150, summing east and west), a subtotal for 2025-01-02 (30), and a grand total row (180, summing everything), 6 rows total, but NO region-only subtotal anywhere in that output: there is no row showing east's total across both dates (130) or west's total (50) on its own.

GROUPING SETS ((date, region), (date), (region), ()) on the same data produces all of that PLUS the missing region subtotals, 8 rows total: the same 3 detail rows; date subtotals 2025-01-01 = 150 and 2025-01-02 = 30; region subtotals east = 130 (100 + 30, across both dates) and west = 50; and the grand total 180. This is the query that actually answers "subtotals by date, by region, and an overall grand total" as the question asks; ROLLUP(date, region) alone silently leaves the by-region half of that ask unmet.

Trade-offs and pitfalls

ROLLUP is hierarchical and order-sensitive: ROLLUP(date, region) rolls up region into date subtotals, not the reverse; ROLLUP(region, date) would instead produce per-region subtotals across all dates. CUBE, by contrast, produces every possible combination of subtotals (all combinations of grouping columns rolled up, not just the nested hierarchy), which is the right tool when you need cross-tabulated totals rather than a strict drill-down hierarchy.

Direct answer
A retention curve is best for showing the OVERALL shape and rate of decay for one or a few cohorts at a glance, a cohort heatmap (matrix) is best for scanning patterns across MANY cohorts simultaneously (spotting which cohorts are better or worse, and whether retention is improving over time), and a raw cohort table is best when exact numbers matter more than pattern-spotting, such as for an audit or a precise calculation.

Structured elaboration

• Retention curve: a line per cohort showing retention percentage over days/weeks since acquisition; strongest insight is the SHAPE of decay (does it flatten into a stable "core" retention level, or keep declining); works well for comparing a small number of cohorts (2-5) but becomes cluttered with many overlapping lines beyond that.
• Cohort heatmap (matrix): rows are cohorts (by acquisition period), columns are periods since acquisition, cells colored by retention rate; strongest insight is spotting PATTERNS across many cohorts at once (e.g. a visible "vertical stripe" of low retention across all cohorts in one specific calendar period signals an external/platform-wide issue, not a cohort-specific one); best for analysts scanning for anomalies across dozens of cohorts.
• Raw cohort table: exact numeric retention values per cohort and period; best when a decision genuinely needs the precise number (e.g. computing a specific cohort's exact day-30 retention for a report), or as an underlying export behind either visual chart.
• Executive vs. analyst preference: executives generally prefer the retention curve (a fast "is retention healthy and stable" read for 1-2 headline cohorts) or a single summary number; analysts generally prefer the heatmap (pattern-scanning across many cohorts) supplemented by the raw table for exact figures when needed.

Worked example
A cohort heatmap immediately reveals that every cohort acquired in a specific month shows unusually low week-1 retention, a pattern a single retention curve (showing only one or two cohorts) would never surface, prompting an investigation into what changed platform-wide that month (a UI change, an onboarding bug) rather than assuming that cohort was simply lower quality. Concretely, a raw cohort table might show (retention % at week 1 / week 2 / week 3 / week 4, each cohort starting from 100% at week 0): January cohort 100 / 42 / 30 / 26, February cohort 100 / 18 / 15 / 13, March cohort 100 / 40 / 31 / 27. Scanning that table row by row, the February cohort's 18% week-1 figure is easy to miss next to two similar-looking rows; on a heatmap, that same 18% cell renders in a visibly darker/redder shade than its 40% and 42% neighbors, making the anomaly jump out instantly rather than requiring a column-by-column read of the raw numbers.

Trade-offs and pitfalls
Using a retention curve to compare many (10+) cohorts produces an unreadable tangle of overlapping lines; that's precisely the situation where a heatmap's color-based pattern-scanning outperforms line-based comparison.