Compound interest is one of those concepts I had nodded along to since high school without really feeling. The formula made sense on paper, the wikipedia chart looked impressive, and yet whenever a friend asked me "so what does 6% over 30 years actually look like?" I had to wave my hands.
This weekend I sat down and wrote it out as code. That single exercise did more for my intuition than a decade of half-attentive reading.
The formula, with names that mean something
The textbook form is:
A = P * (1 + r/n)^(n*t)
Which is fine if you already understand it. Here is the same thing as a function with names a beginner can read:
function futureValue({ principal, annualRate, compoundsPerYear, years }) {
const r = annualRate / compoundsPerYear;
const n = compoundsPerYear * years;
return principal * Math.pow(1 + r, n);
}
console.log(futureValue({
principal: 10000,
annualRate: 0.06,
compoundsPerYear: 12,
years: 30,
}));
// 60225.75...
Ten thousand dollars at 6 percent, compounded monthly for 30 years, becomes about sixty thousand. Six times the original. No new contributions. That is the entire pitch of long-term investing in one console.log.
Why monthly compounding matters less than you think
The first thing this snippet let me play with is the compoundsPerYear parameter. Try 1, 12, 365, then a million. The answer barely moves after about 12. Compounding more often than monthly is mathematically fancier but practically marginal at normal rates. Most of the magic is the rate and the time.
If you want a UI version of the same calculation with a yearly breakdown table, the Compound Interest Calculator on Equation Solver shows the row-by-row growth so you can see exactly when the curve starts bending upward. It is the same formula my function uses, just rendered with inputs and a table.
Reframing the question for a mortgage
Once I had the future-value function, I realized the same algebra runs in reverse for loans. A mortgage payment is the constant monthly amount that brings a loan balance from P down to zero over n months at rate r:
function monthlyPayment({ principal, annualRate, years }) {
const r = annualRate / 12;
const n = years * 12;
return (principal * r) / (1 - Math.pow(1 + r, -n));
}
console.log(monthlyPayment({
principal: 300000,
annualRate: 0.065,
years: 30,
}));
// 1896.20...
Seeing it as code made me realize how brutal small rate changes are. Drop the rate from 6.5 to 5.5 percent and the payment falls by more than $190 a month. Multiply by 360 months and that is over $68,000 across the life of the loan, on a single point of rate. I have been quoting that number to friends ever since.
When I want a full amortization schedule rather than just the payment, I open the Mortgage Calculator on Equation Solver and watch how the principal and interest split shifts month by month. The first few years are almost entirely interest. That is also obvious from the formula, but seeing the table makes it real.
Retirement is just compound interest with contributions
The final piece is what happens when you add money every month. The clean way to see it is:
function retirementBalance({ monthly, annualRate, years }) {
const r = annualRate / 12;
const n = years * 12;
return monthly * ((Math.pow(1 + r, n) - 1) / r);
}
console.log(retirementBalance({
monthly: 500,
annualRate: 0.07,
years: 35,
}));
// 858422.95...
Five hundred dollars a month for 35 years at 7 percent annual return ends up close to $860k. No lottery, no genius stock picks, just a habit and time. The Retirement Calculator on Equation Solver wraps the same math with a nicer UI and lets you sweep across contribution levels and rates.
What I took away
Writing these three tiny functions side by side made the connection click. Saving, borrowing, and retiring are all the same exponential machine wearing different costumes. Once you have a Math.pow(1 + r, n) and a clear naming convention, the rest is just deciding whether you are solving for the future balance, the payment, or the contribution.
If you teach or mentor anyone learning programming, financial calculators are a surprisingly good first project. The math is small, the inputs are intuitive, and the output finally makes the abstract formula feel like real money. Ten years from now, that intuition is worth more than the code.
Top comments (0)