TL;DR: For tabular enterprise data, gradient-boosted trees are the default winner because they handle mixed types, nonlinearities, and missing values with almost no preprocessing. The default flips two ways: a hard interpretability or regulatory requirement (linear or monotonic model) and unstructured inputs like text or images (neural nets and embeddings).
How to approach it
State the empirical prior up front, then show it's a reasoned default rather than a reflex: "For tabular enterprise data, the bulk of what FDEs deploy, gradient-boosted trees (XGBoost/LightGBM) are the default winner. But I'd start by asking about data size, latency budget, explainability requirements, and who maintains this after I leave."
A strong answer
The decision logic, by model family:
Linear models (logistic/ridge/lasso), choose when: data is small (<10k rows), the compliance team must audit coefficients (credit decisioning under fair-lending rules effectively mandates this), latency is sub-millisecond, or you need a baseline in day one of the pilot. Limits: only captures additive linear effects unless you hand-engineer interactions. Underrated FDE virtue: a regulated customer can adopt a model their risk team understands; a better model they can't audit ships never.
Gradient-boosted trees, the tabular workhorse, and you should explain why they win: they natively handle mixed feature types and different scales (no normalization needed), are robust to outliers and missing values, capture non-linearities and feature interactions automatically, and are sample-efficient in the 10k–10M row range where enterprise datasets live. Benchmarks (and a decade of Kaggle plus the "trees beat deep learning on tabular data" literature) keep confirming it. Training a strong model takes minutes on a single node, which matters when you're iterating inside a customer's locked-down environment. Pair with SHAP for explainability.
Neural networks, choose when the data isn't really tabular: text, images, audio, sequences, or when you need embeddings, multi-task learning, or fusion of tabular + unstructured inputs (claim records + adjuster notes + damage photos). On pure tabular data they typically need more rows, more tuning, and GPU infrastructure to match XGBoost. The honest line that scores well: "I reach for deep learning when the data type demands it, not the ambition level of the project."
The selection logic as a single tree you can sketch on the whiteboard:
Micro-example to make it land: customer churn, 80k rows, 60 mixed features. Day 1: logistic regression baseline, AUC 0.74, now everything has a yardstick. Day 3: LightGBM, AUC 0.82. A tuned neural net after a week: 0.81, with 10× the serving complexity. Ship the GBM; keep the linear model as the explainable fallback. That sequence, baseline, boost, justify, is the deployment pattern interviewers at Databricks want narrated.
The three families side by side:
| Model | Training cost | Interpretability | Preprocessing | Best when |
|---|---|---|---|---|
| Tree ensemble (XGBoost) | Minutes on a single node | SHAP | Almost none; handles mixed types, outliers, missing values | Tabular, 10k to 10M rows |
| Linear | Day-one baseline | Auditable coefficients | Hand-engineer interactions | Small data (<10k), regulatory audit, sub-ms latency |
| Neural net | More tuning, GPU infrastructure | Lower; embeddings | Heavier; needs more rows | Text, images, audio, sequences, or fusion |
What interviewers probe next
- "Why do trees beat neural nets on tabular data?", tabular signal is often in sharp thresholds and irregular interactions; trees represent axis-aligned splits natively, while neural nets must approximate them with smooth functions; trees also tolerate uninformative features that distract gradient training. One concrete threshold makes the mechanism vivid: in US banking data, behavior changes discontinuously at $10,000 because that is the currency-transaction reporting line, so fraudsters structure transfers at $9,900 and the signal is a cliff, not a slope. A tree spends one split (
amount >= 9990) and captures it exactly. A neural net must build that step out of smooth sigmoids, which takes multiple units, more data, and careful training to sharpen, and until it succeeds the model blurs the one boundary the domain actually contains. Enterprise tabular data is full of such cliffs (policy limits, eligibility ages, contract tiers, regulatory lines), which is why the empirical result has held for a decade: the inductive bias of axis-aligned splits matches how institutional rules carve the world. - "When would you upgrade a working GBM to a neural net?", new unstructured inputs, need for shared embeddings across tasks, or extreme scale where a single model serves many related problems.
- "Random forest vs gradient boosting?", RF averages independent deep trees (variance reduction, hard to overfit, less tunable); boosting fits shallow trees sequentially to residuals (usually more accurate, easier to overfit, use early stopping).
- "How does the customer maintain this?", GBMs retrain cheaply on schedule; document the feature pipeline; that operational answer is half the question.
Common mistakes
Recommending deep learning to look sophisticated, the panel reads it as demo-thinking. Skipping the linear baseline, leaving no evidence the complexity paid for itself. Ignoring the maintenance question entirely. And being unable to explain why trees win on tabular, the empirical fact without the mechanism caps you at mid-level.