30 min

Securitisation: tranching a pool of loans

An SPV issues securities against pooled loan cash flows that pay top down and absorb losses bottom up, which is how a safe senior tranche is built from loans that are not safe; 2008 is what happens when the inputs are wrong.

Where you are. You have a pool of loans and a rule for splitting what they pay. This lesson does the thing that rule makes possible: turning one pool of risky loans into several securities of genuinely different risk, sold to different buyers. It is an elegant piece of engineering, and it is also the machine at the centre of 2008, which makes it worth understanding precisely rather than through slogans.

A pension fund that cannot buy any of these loans

Two thousand mortgages sit in a pool. Individually, none of them is investment grade: each borrower might lose a job, and a pension fund with strict rules cannot hold that risk.

Yet the pool as a whole is highly predictable in one respect. Almost all of these borrowers will pay. Historically a small percentage will not, and while nobody can say which, the aggregate is far steadier than any individual loan.

So: sell the pension fund a claim that only fails if an implausibly large fraction of the pool fails, and sell somebody with more appetite the claim that fails first. Same loans, two securities, genuinely different risks - built not by changing the loans but by choosing an order.

The idea in one paragraph

Securitisation pools loans into a separate legal entity and issues securities against their cash flows, and tranching splits those securities into slices with a fixed loss order. Payments flow from the top down: the senior tranche is paid first, then mezzanine, then junior. Losses flow from the bottom up: the junior tranche absorbs the first losses entirely, and only when it is exhausted does mezzanine take any, and only when that is gone does senior. The junior slice is therefore small, risky and highly paid, and the senior slice is large, safe and cheaply paid - safe not because the loans are safe, but because a thick cushion of other people’s money sits underneath it. The whole construction rests on one assumption, and 2008 is what happened when that assumption turned out to be wrong.

Losses from the bottom

The exercise runs three scenarios on a pool split ten percent junior, twenty percent mezzanine, seventy percent senior.

A mild loss of three percent is absorbed entirely by the junior tranche, which loses a third of itself. Mezzanine and senior lose nothing at all - that is what they paid for by accepting a lower return.

A bad loss of fourteen percent wipes the junior tranche out completely and takes a fifth of mezzanine. Senior is still untouched.

A severe loss of thirty-five percent destroys junior and mezzanine entirely and finally reaches senior, which loses about seven percent of itself.

image/svg+xml Matplotlib v3.11.1, https://matplotlib.org/ 0 10 20 30 40 pool loss, percent 0 20 40 60 80 100 percent of the tranche wiped out junior mezzanine senior the junior tranche absorbs everything until it is gone
Each tranche's losses as the pool's total loss grows: junior absorbs everything until it is gone, then mezzanine, then senior

The assumption that failed

The senior tranche’s safety is a claim about correlation. If defaults are independent - one borrower losing a job tells you nothing about the next - then large aggregate losses are vanishingly unlikely, and thirty percent of subordination is enormous protection.

If defaults are correlated, everything changes. A national fall in house prices is not two thousand independent events; it is one event affecting two thousand loans. Under that condition the pool’s losses can easily exceed the junior and mezzanine cushions together, and the senior tranche is exposed to precisely the scenario it was sold as being immune to.

The arithmetic in the exercise is correct throughout. It is the input - how correlated the defaults are - that decides whether the senior slice deserved its rating, and that input was badly wrong.

Why the vehicle is separate

The pool sits in its own legal entity so that its cash flows belong to the securities’ holders and nothing else. If the bank that originated the loans fails, the pool is not part of its estate.

That isolation is genuinely valuable and it cuts both ways. It also means the originator can sell the loans and stop caring how they perform - which is exactly the incentive problem that produced a great deal of very bad lending in the years before 2008, and why rules now require originators to retain a slice of what they sell.

Check yourself

1. How can a safe security be built from loans that are individually not safe?

By subordination. The senior tranche only takes losses after the junior and mezzanine tranches have been wiped out, so it is protected by a thick cushion of other investors’ money. Its safety comes from its position in the loss order, not from any change to the underlying loans.

2. A pool loses fourteen percent. Which tranches are hit, given a 10/20/70 split?

The junior tranche, which is wiped out entirely by the first ten percent, and mezzanine, which absorbs the remaining four percent - a fifth of itself. Senior loses nothing, because losses have not yet eaten through the thirty percent standing beneath it.

3. What assumption makes a senior tranche safe, and what happens when it is wrong?

That defaults are largely independent, so a large aggregate loss is very unlikely. If defaults are correlated - a national house-price fall rather than two thousand separate misfortunes - losses can exceed both subordinate tranches together and reach the senior slice, which was sold on the basis that they could not.

4. Why does isolating the pool in a separate entity create an incentive problem?

Because the originator sells the loans and keeps the fee, so its exposure to how they perform ends at the sale. That weakens its reason to lend carefully, which is why rules now require originators to retain a slice of what they issue - putting some of their own money back in the loss order.

Do this

Allocate losses across the tranches and find where each one breaks.

python3 code/tranching.py

The starter leaves you allocate_losses: walk the tranches from junior upward, letting each absorb up to its own size before the next takes anything. The assertions check that every loss lands somewhere, that a small loss never reaches senior, and that a large enough one reaches everybody. Success prints three scenarios with the wiped-out tranches named, and the line:

the pool never changed; only the order of who absorbs its losses did, and that order is the entire product

The completed version is in solutions/tranching.py.

What you can now do. You can allocate losses across a tranched structure and name the assumption a senior slice depends on. That closes the amplifier half of this module. The rest is the safety net, starting with the daily discipline that keeps a levered position from ever accumulating an unpaid loss.

What you can now do

You can allocate a pool's losses across tranches and say exactly which assumption makes a senior slice safe.