The computation of Social Security benefits uses only basic arithmetic, but it still seems fairly complicated. That's because there are many moving parts to the formula. To increase my own understanding of it, I put together a customizable Excel sheet that calculates monthly payouts based on an individual's earnings over the years.

## Social Security quirks

At a high level, the Social Security formula calculates an individual's average monthly earnings and then uses a regressive tax system to calculate the monthly payout. First, the individual's highest 35 years of income are determined, and the average indexed monthly earnings (AIME) are calculated. Then, the AIME is multiplied by a variable regressive rate to calculate the primary insurance amount (PIA). Finally, the PIA is scaled up or down based on how early or late in life an individual starts collecting their benefits. For individuals born after 1960, full retirement age is 67, but benefits can be collected at a reduced PIA as early as age 62.

One reason for the formula's complexity is that it's set up to encourage more equitable distributions. Low earners or individuals forced to leave the workforce early are not stuck with a significantly lower monthly payout. This is managed by a few nifty tricks:

- Each year has a predetermined cap that limits how much of an individual's income from that year can be considered for Social Security benefits.
- Each year has an index factor applied to the earnings to account for inflation. The set of index factors used is based on when the individual turns 62.
- The variable rate that converts AIME to PIA works like a regressive tax, i.e. the first few AIME dollars contribute most of their value to the payout while the last few dollars contribute the least. The formula has 3 "tax" brackets – 90%, 32%, and 15% – that are separated by dollar amounts known as "bend points."

## Google Sheets quirks

In addition to cementing my understanding of the Social Security formula, I also discovered new Excel functions and their quirks. I thought my learnings were interesting enough to share.

### 1. `LARGE()`

The `LARGE(range, n)`

function retrieves the `n`

-th largest value from a `range`

of cells. This is a very useful function, but when I first tried using it to sum up the 35 highest years of earnings, it seemed to error when `n`

>= 32. As a programmer, 32 seemed like a reasonable limit, and I didn't question it.

It wasn't until well after I'd found a workaround that I realized my cell references had been relative instead of absolute, so the last few rows in my calculations had been referencing ranges with fewer than 32 cells of data. So silly! (But maybe the error message could have been better too.)

Separately, Microsoft Excel has a slightly stronger version of this function than Google Sheets. In Excel, the `n`

can also be an array of numbers so that multiple results are returned instead of just one. Google Sheets doesn't support this.

To work around the limitations I thought I had, I switched to using `SORT(range, column, [is_ascending])`

to sort all earnings and then sum only the top 35 cells from the results. It worked like a charm!

### 2. `ROUND()`

vs. `FLOOR()`

The `ROUND(num, [places])`

function rounds `num`

up or down depending on whether the next significant digit (following the digit being rounded) is >=5 or <5 respectively. The optional `places`

parameter is the number of decimal places to which to round, 0 by default.

A similar but very different function, `FLOOR(num, [factor])`

always rounds down to the nearest multiple of `factor`

. For example:

`FLOOR(5.6, 1) = 5`

`FLOOR(5.6, 0.5) = 5.5`

The use of `factor`

instead of `places`

initially threw me off, but now that I've had time to think about it, I really like the flexibility that `factor`

offers.

Of course, if you prefer a version of `FLOOR()`

that matches the `ROUND()`

function's parameters, there's always `ROUNDDOWN(num, [places])`

.

### 3. `SEQUENCE()`

After I removed the use of `LARGE()`

, I no longer needed `SEQUENCE()`

either, but this function deserves a shoutout. It produces a simple range of cells numbered from 1 to any `n`

of your choosing, and it even accepts parameters to change the starting number, the step size, and the number of columns created. There have been so many times in the past where I've needed a simple sequence of numbers like this and not known how to create it. Well, here it is!

I've said it before, and I'll say it again – isn't Excel cool? Programming at its finest.