Month: January 2025

Interest-rate volatility is one of the most important factors anyone considers when taking out or changing their mortgage. One of the main things volatility can influence is the term of the mortgage, which can also vary significantly based on where you live. For example, in areas such as the Netherlands mortgages periods are typically significantly longer than those issued here in the United Kingdom, with 15-20 year terms not being unusual. One rather obvious benefit of this is that purchasers are shielded against rising rates — the inverse being that if rates fall you’re stuck with what you started on. A potentially more subtle downside to this is that you can’t benefit from any changes to your loan-to-value ratio; as you pay your mortgage off your mortgage your LTV decreases which may allow you to apply for better rates. This challenge is further compounded by the fact that you don’t pay a static amount of interest every month due to mortgage amortisation, which we’ll discuss this more below.

Some newer lenders have made efforts to offset this, such as the Dutch firm April who have recently started issuing mortgages which automatically adjust your LTV as you pay them off — though interestingly don’t provide much marketing information on just how much of a difference this can actually make. In the UK, shorter fixed-rate periods are more common so we potentially benefit from LTV changes automatically as fixed period cycles are shorter. Again however, the impact of this in relation to how these changes can interact with your mortgages overall cost isn’t always made abundantly clear. The case we’re going to be discussing here specifically, is how rate-changes can impact your overall mortgage cost can vary quite a bit based on when they happen over the lifetime of the mortgage.

Some context on mortgage amortisation

Mortgage amortisation is the process by which lenders ensure that your mortgage payments remain stable over time. Without this in place, as you paid off more of the principal of the mortgage the percentage of interest being charged each month would amount to a different price as it would constantly be calculated against a different amount.

In order to calculate the overall mortgage schedule, we only need two functions :
i. The total monthly payment each month
ii. The amount that month that is going towards the monthly principal (the amount of interest being the difference)

$${\displaystyle \begin{array}{c}i=interestRate\\ n=numberOfMonthsRemaining\end{array}}$$ $${\displaystyle \begin{array}{c}totalMonthlyPayment=loanAmount({\displaystyle \frac{(i\times (1+i{)}^2)}{(1+i{)}^n-1}})\end{array}}$$ $${\displaystyle \begin{array}{c}PrincipalPayment=totalMonthlyPayment-(outstandingLoanBalance\ast (i/12)))\end{array}}$$

From these we can calculate each month by iteratively calling calc_total_monthly_payment on the balance generated by the previous months output. Quickly testing this, we can see that it works (function implementations below in the main body of the code:

utop # let first_month_total_payment = calc_total_monthly_payment 100000. 0.4 10.
let first_month_principal = calc_total_monthly_principal first_month_total_payment 100000. 0.4
let second_month_total_total_payment = calc_total_monthly_payment (100000. -. first_month_principal) 0.4 9.;;

val first_month_total_payment : float = 11923.3425628468303
val first_month_principal : float = 8590.00922951349639
val second_month_total_total_payment : float = 11923.342562846834

Here we can see that when we recalculate the amount we should be paying each month, it’s outputting the same amount (notice in this case it’s not exactly the same amount, this is due to some floating point arithmetic errors, but it’s good enough for our purposes here, obviously don’t do this in production!).

Main analysis

First, let’s set up a base line case. In this scenario we’re going to imagine a mortgage running with a fixed rate over it’s entire lifetime. To do this we’re going to use the following:

mortgage.ml

open Types
module B = PrintBox

(* stolen from https://github.com/dbuenzli/gg/blob/8f761c278d0b2ee2adb94f9fbc033f1bfd76e536/src/gg.ml#L123-L126 *)
let round_dfrac d x =
  if x -. Float.round x = 0.
  then x
  else (
    (* x is an integer. *)
    let m = 10. ** float d in
    (* m moves 10^-d to 1. *)
    floor ((x *. m) +. 0.5) /. m)
;;

let format_rows (rows : row list) =
  let get_row_arr r =
    let year, month = r.year_month in
    [| B.int year
     ; B.int month
     ; B.float @@ round_dfrac 2 r.payment
     ; B.float @@ round_dfrac 2 r.interest
     ; B.float @@ round_dfrac 2 r.principle
     ; B.float @@ round_dfrac 2 r.loan_balance
     ; B.float @@ round_dfrac 2 r.end_period_balance
    |]
  in
  let rec get_rows rows converted_rows =
    match rows with
    | [] -> converted_rows
    | [ r ] -> get_row_arr r :: converted_rows
    | r :: xr -> get_rows xr (get_row_arr r :: converted_rows)
  in
  let output = get_rows rows [] in
  let output_with_headers =
    Array.of_list
    @@ ([| B.sprintf "Year"
         ; B.sprintf "Month"
         ; B.sprintf "Payment"
         ; B.sprintf "Interest"
         ; B.sprintf "Principle"
         ; B.sprintf "Loan balance"
         ; B.sprintf "End period balance"
        |]
        :: output)
  in
  output_with_headers |> B.grid
;;

let calc_total_monthly_payment principal annual_interest number_of_payments =
  let monthly_interest = annual_interest /. 12.0 in
  let numerator =
    monthly_interest *. Float.pow (1.0 +. monthly_interest) number_of_payments
  in
  let denominator = Float.pow (1.0 +. monthly_interest) number_of_payments -. 1.0 in
  principal *. (numerator /. denominator)
;;

let calc_total_monthly_principal total_monthly_payment outstanding_balance interest_rate =
  let monthly_interest_rate = interest_rate /. 12. in
  total_monthly_payment -. (outstanding_balance *. monthly_interest_rate)
;;

let calculate_rows principal interest_rate term_years =
  let total_number_of_payments = float_of_int @@ (term_years * 12) in
  let calculate_month year month remaining_balance =
    let total_monthly_payment =
      (* calc_total_monthly_payment principal interest_rate number_of_payments *)
      calc_total_monthly_payment principal interest_rate total_number_of_payments
    in
    let monthly_principal =
      calc_total_monthly_principal total_monthly_payment remaining_balance interest_rate
    in
    { year_month = year, month
    ; loan_balance = remaining_balance
    ; payment = total_monthly_payment
    ; interest = total_monthly_payment -. monthly_principal
    ; principle = monthly_principal
    ; end_period_balance = remaining_balance -. monthly_principal
    }
  in
  let rec calc_all_months outstanding_balance year month schedule months_calculated =
    if total_number_of_payments <= months_calculated
    then schedule
    else (
      let next_month_details = calculate_month year month outstanding_balance in
      let next_year = if month == 12 then year + 1 else year in
      let next_month = if month == 12 then 1 else month + 1 in
      let new_outstanding_balance = next_month_details.end_period_balance in
      let updated_schedule = next_month_details :: schedule in
      calc_all_months
        new_outstanding_balance
        next_year
        next_month
        updated_schedule
        (months_calculated +. 1.))
  in
  calc_all_months principal 0 1 [] 0.
;;

let calc_summary principal rows =
  let total_cost =
    let rec calc_total_cost rows sum_so_far =
      match rows with
      | [] -> sum_so_far
      | [ r ] -> calc_total_cost [] (sum_so_far +. r.payment)
      | r :: rs -> calc_total_cost rs (sum_so_far +. r.payment)
    in
    calc_total_cost rows 0.
  in
  { Summary.total_cost;
  principal}
;;

and following plot.ml for plotting our output:

open Owl
open Owl_plplot
open Types

let graph rows =
  let x_axis_months =
    Array.of_list
    @@ List.map
         (fun row ->
           let year, month = row.year_month in
           float_of_int @@ ((year * 12) + month))
         rows
  in
  let end_balance_by_month =
    Array.of_list @@ List.map (fun row -> row.end_period_balance) rows
  in
  let interest_by_month = Array.of_list @@ List.map (fun row -> row.interest) rows in
  let principle_by_month = Array.of_list @@ List.map (fun row -> row.principle) rows in
  let x_axis = Mat.of_array x_axis_months (Array.length x_axis_months) 1 in
  let y_axis_end_balance =
    Mat.of_array end_balance_by_month (Array.length end_balance_by_month) 1
  in
  let y_axis_interest =
    Mat.of_array interest_by_month (Array.length interest_by_month) 1
  in
  let y_axis_principle =
    Mat.of_array principle_by_month (Array.length principle_by_month) 1
  in
  let h = Plot.create ~m:2 ~n:1 "output.pdf" in
  Plot.subplot h 0 0;
  (* Plot.set_foreground_color h 0 50 255; *)
  (* Plot.set_background_color h 0 0 0; *)
  Plot.set_page_size h 1000 1000;
  Plot.(
    plot
      ~h
      ~spec:[ RGB (255, 0, 0); LineStyle 1; Marker "#[0x2299]"; MarkerSize 8. ]
      x_axis
      y_axis_end_balance);
  Plot.(legend_on h ~position:NorthEast [| "remaining-balance" |]);
  Plot.subplot h 1 0;
  Plot.(scatter ~h ~spec:[ RGB (255, 0, 0); LineStyle 1 ] x_axis y_axis_interest);
  Plot.(scatter ~h ~spec:[ RGB (255, 0, 0); LineStyle 2 ] x_axis y_axis_principle);
  Plot.(legend_on h ~position:East [| "interest"; "principle_payment" |]);
  Plot.output h
;;

then our resulting main.ml looks something like:

module B = PrintBox
open Mortgage__Types

let principal = 500000.0
let interest_rate = 0.0591
let term = 20
let rows = Mortgage.calculate_rows principal interest_rate term
let summary = Mortgage.calc_summary principal rows;;

PrintBox_text.output ~style:true stdout @@ Mortgage.format_rows rows;;
print_endline "";;
Mortgage__Plot.graph rows

let () = print_endline (Summary.show summary)

We can see from the configuration in our main, that we’re running against a £500000 mortgage, to be paid over 20 years, at a fixed rate of 5.91%. Running, this produces the following amortisation schedule.

From this we can see that the schedule is doing what it’s meant to be doing; our monthly payments are stable, and we’re slowly paying our way down to a balance of 0. Overall our £500000 mortgage has cost us £853498.

Graphing this out further illustrates this in practice (y = amount paid that month, x = time in months).

This again illustrates the difference in interest vs principal payment accross the lifetime of the mortgage, particularly at the early phase when the bulk of each payment is just going towards interest. In an ideal world we’d want to bring the crossing point much earlier so we’re contributing towards the balance in greater volume earlier on as this will reduce the amount of interest we pay off over the lifetime of the mortgage. To do this we’re going to imagine that each time we calculate the monthly payment, we’re going to recalculate the loan-to-value ratio, and calculate the interest rate based off this. A few changes are required to do this but for brevities sake, let’s just look at the function for calculating interest rate (the full code changes required can be found on my github):

(* static sample rates, pulled from Bank of England data here: *)
(* https://www.bankofengland.co.uk/statistics/visual-summaries/quoted-household-interest-rates                                          *)

let calculate_interest_rate value outstanding_principle =
  let ltv = outstanding_principle /. value in
  if (ltv >= 0.95) then 0.0591
  else if (ltv >= 0.90) then 0.0545 
  else if (ltv >= 0.85) then 0.0503 
  else if (ltv >= 0.75) then 0.0473 
  else  0.0462

Now if we rerun our simulation, we can see the impact of this:

From this we can see a pretty significant reduction in the overall cost of the mortgage by over £61000.

The immediate implications of this are obvious. Factoring in loan-to-value can have a major impact on how much interest you’re paying, which results in more of your monthly payment going towards the loan principle.

In reality it’s obviously not as simple as this and there are countless factors which can be beneficial / detrimental to your individual position, but that’s not to say that this isn’t an unimportant factor. A good example of where this interaction might be beneficial is in areas where asking prices and sales prices don’t match up. Often lenders are restricted to the amount they can lend based on the reported-valuation, forcing buyers to make up the shortfall in cash. Any initial LTV calculation is based off this valuation, however subsequent calculations may be more in line with the sales price, having a significant impact on the LTV. In an environment where interest rates are stable, taking out a shorter term could allow a borrower to re-asses their LTV with their lender earlier, potentially leading to a reduction in rates at an earlier stage in their mortgage.

The code used above is fairly crude in terms of the data it uses but hopefully provides at least a basic illustration of some of the interactions involved. Full source can be found on github.

Please note, any information in the above is not intended nor does it constitute financial, tax, legal, investment, or other advice. Before making any decision or taking any action regarding your finances, you should consult a qualified Financial Adviser.