The recoup waterfall, modelled

Why model a contract#

Publishing contracts are piecewise-linear functions of revenue. That makes them easy to reason about and easy to misjudge, because the pieces that matter (the recoup threshold, the split during recoup, a multiplier) interact. A 75/25 split sounds better than 70/30 until you notice it starts at 1.5× recoup. This post writes four common structures as equations, finds where each one beats self-publishing, and then runs them against a realistic, uncertain revenue distribution to compare expected value and downside.

Code: research/recoup_waterfall.py. Revenue here always means net receipts: platform payouts after fees, refunds and taxes.

Four structures as equations#

Let $R$ be lifetime net receipts and $B$ the publisher's recoupable spend. The studio's take $S(R)$:

where $x^{+}=\max (x,0)$. The self-publishing line is the studio funding the same $B$ itself and keeping all receipts, so it can go negative. The second line is Ammighty's standard deal; the other two are structures we regularly see in competing term sheets.

Where each deal stops beating self-publishing#

Studio take as a function of net receipts. Dashed black: self-publishing with the same budget. All axes in units of B, so the picture holds for any budget size.

Set $S_{\text{deal}}(R)=S_{\text{self}}(R)$ and solve. For the share structure above recoup:

In general, with a during-recoup share $a$ and post-recoup share $s$:

So the straight 60/40 deal ($a=0$) and the 1.5× multiplier deal both cross self-publishing at $R^{\ast }=B$: the moment a self-published game breaks even, it beats those deals forever. The share structure keeps beating self-publishing until $R=1.5B$, i.e. until the game makes 50% more than its budget. The simulation confirms the crossovers numerically: Straight recoup, then 60/40 at 1.00B; 15% during recoup, then 70/30 at 1.50B; Recoup 1.5×, then 75/25 at 1.00B.

Adding uncertainty: expected value and downside#

Crossovers are about a known $R$. Studios sign before they know it. We drew 400,000 revenue outcomes from the same lognormal launch model used in our wishlists Monte Carlo, at 150,000 launch wishlists with a $500k budget (median receipts $582k, mean $887k), and computed each structure's take:

Self-publishing has roughly the same mean as the share deal but a 43% chance of losing money, with a 10th percentile of $-321k. For a small studio, that tail is the whole company. The share deal has no loss scenarios by construction and puts $27k in the studio's pocket even at the 10th percentile.

How much must a publisher add?#

A publisher is supposed to grow revenue through marketing, platform relationships, localisation and ports. Call that a multiplier $u$ on receipts. The question a studio should ask is: what $u$ makes the deal's expected take match self-publishing?

A 20%+ uplift is achievable for a strong publisher, but it's a promise you should ask them to back with specifics: marketing commitment in the contract, named platform programmes, localisation scope. A share structure needs no such faith to be worth signing.

Limitations#

Real contracts have more pieces: stepped splits, marketing caps, platform-specific splits, sequel options, minimum guarantees. Each adds a kink to $S(R)$, and the method above still works: write it piecewise, find crossovers, integrate against a revenue distribution. We ignore the time value of money (publisher money arrives earlier, which favours deals) and taxes. The revenue distribution is a model calibrated to one public benchmark, not a forecast for your game. Use the deal calculator for quick numbers, and the script for anything you'll sign.

Reproduce it#

The full script is research/recoup_waterfall.py (Python 3.10+, numpy, scipy; fixed seeds, so you'll get the same numbers). This is the core of it:

def take(kind, R):
    if kind == "straight_60":   return np.where(R <= B, 0.0, 0.60 * (R - B))
    if kind == "ammighty":      return np.where(R <= B, 0.15 * R, 0.15 * B + 0.70 * (R - B))
    if kind == "multiplier_75": return np.where(R <= 1.5 * B, 0.0, 0.75 * (R - 1.5 * B))
    if kind == "self":          return R - B

# uplift u at which E[deal(u*R)] equals E[self-publish(R)]
gap = lambda u: take_b(kind, u * R, B_EV).mean() - take_b("self", R, B_EV).mean()
u_star = brentq(gap, lo, hi)

Run it with python3 research/recoup_waterfall.py; results land in research/out/, and the site's tables and charts are rendered from that JSON at build time. To test a term sheet you've been offered, add it as another branch of take(). Stepped splits and caps are just more np.where pieces.

Frequently asked questions#

Sources#

1. Game World Observer, "Wishlist-to-sales ratio on Steam: GameDiscoverCo benchmark", 6 Dec 2024 (calibration of the revenue distribution). gameworldobserver.com/2024/12/06/wishlist-to-sales-ratio-steam-gamedis