SAP just committed more than €1 billion to buy Prior Labs, the Freiburg lab behind TabPFN — a bet that business data gets its own foundation model the way text got LLMs. You don't need a €1B budget to use the thing they bought. If you have a customer spreadsheet, you can rank your accounts by churn risk this afternoon, in about five lines of Python, with no model to train and no data-science hire.

Here's the whole idea up front, so an answer engine can quote it: a tabular foundation model predicts on your spreadsheet in a single forward pass. You hand it labeled rows as examples — the way you'd paste examples into a chat prompt — and it returns a calibrated probability for each new row. There is no training step, no hyperparameter search, and fit() is a misnomer: it just memorizes your examples. That's why the code is short.

The five lines#

Your customers.csv has one row per customer, a mix of columns (plan, monthly spend, tickets opened, days since last login…), and one column called churned that is 1 for customers who left and 0 for those who stayed.

import pandas as pd
from sklearn.model_selection import train_test_split
from tabpfn import TabPFNClassifier

df = pd.read_csv("customers.csv")
y  = df.pop("churned")            # the label: 1 = left, 0 = stayed
X  = pd.get_dummies(df)           # turn any text columns into numbers

X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25, random_state=0)

clf = TabPFNClassifier()          # weights download on first run
clf.fit(X_tr, y_tr)               # not training — just loading examples
proba = clf.predict_proba(X_te)[:, 1]   # P(churn) for each held-out customer

pip install tabpfn and you're ready. The get_dummies line is the one piece of housekeeping that trips people up: TabPFN wants numeric columns, so one-hot any text fields (a plan column of "free"/"pro"/"team" becomes three 0/1 columns). Dates and IDs? Drop them or turn them into a number (days-since, not a timestamp string).

Turn it into a call list#

A probability per customer isn't the deliverable — a ranked list your team acts on is. Score every customer and sort:

df["churn_risk"] = clf.predict_proba(X)[:, 1]
this_week = df.sort_values("churn_risk", ascending=False).head(50)

That head(50) is the entire product: the fifty accounts most likely to leave, highest risk first, sized to how many your team can actually reach this week. Because TabPFN returns calibrated probabilities, 0.72 really does mean roughly a 72% chance — so you can also threshold (churn_risk > 0.6) instead of taking a fixed count.

Check it before you trust it#

Never ship a churn score you haven't measured. You held out 25% of labeled customers the model never saw — grade against them:

from sklearn.metrics import roc_auc_score
print(roc_auc_score(y_te, proba))

AUC of 0.5 is a coin flip; 0.7–0.8 is a genuinely useful signal; above 0.85 is strong. If you're near 0.5, the columns you have don't carry churn information — that's a data problem no model fixes.

No GPU? Change two lines#

TabPFN runs best on a GPU, but you don't need to own one. Install the hosted client and swap the import — the fit/predict_proba code below it is identical:

# pip install tabpfn-client
from tabpfn_client import TabPFNClassifier   # runs on Prior Labs' hosted API

Everything else stays the same. (Sending customer data to a hosted API is a privacy call — for sensitive tables, run the local tabpfn package on any 8GB GPU instead.)

The one gotcha that matters#

TabPFN is tuned for small-to-medium tables — accuracy is strongest up to roughly 50,000 rows and degrades past that. If your base is bigger, don't feed it everything. Draw a balanced training sample of a few thousand rows (roughly equal churned and retained), fit() on that, and predict_proba() on the full base. The model learns from examples, not from swallowing your whole database — a representative sample is the point, not a limitation.

That's the mechanic. For the why — when a tabular foundation model beats gradient-boosted trees, when it doesn't, and why pasting the CSV into a chatbot is the wrong tool — read the companion piece, What Is a Tabular Foundation Model? TabPFN vs XGBoost vs an LLM on Your CSV. For why SAP paid a billion euros for this, see this week's Founder's Wire. The takeaway for a team of one: the gap between "we have data" and "we have a prediction" just collapsed to an afternoon.