Both my and my girlfriend get our wages paid into separate bank accounts. This is quite common for a lot of couples but can present quite an organizational challenge when you've got joint bills to pay.

For example, does one person pay the mortgage and the other pay the food & utility bills (I think this was how my dad arranged it when he was married), is this always fair? Or would you both pay X amount into a set account and then hope that the value doesn't change too much.

An alternative solution might be to have both wages paid into a single joint account and then divide the total income evenly once the bills have been processed but that can sometimes also be undesirable depending on how close you are with your partner and how large the pay gap is between you.

I bring this question up in conversation with friends sometimes and I get a range of responses so clearly everyone has a different approach to this problem

Not so simple after all

The approach I take is the "both pay X amount into a joint account" option. We have a joint account that is responsible for ensuring that the bills get paid and we top it up on payday to ensure there are funds in the account to pay for the bills when they are needed. This is really good for us as it means that a bulk of our wages are ring fenced away so that they cannot be spent on other items during the month. Whatever is left after payday is "fair game".

This presents a few issues however

• How do we top it up? Bank Transfer or Standing Order?
• What if the amount changes? How will we know?
• Will we even remember to pay into this account?
• How do we keep track of who pays what?

I feel as though the system I currently use (and have been using for the last 2 years is the most simple solution to this issue for me). Here's the explanation:

We'll start with the data

To keep things simple here, I store all this data in Excel. Since we're storing a simple single table with generally no overlapping or relational elements, a simple flat file table is much easier here than any sort of complicated database. Here's what this looks like:

The provider field is surplus to requirements but it does help keep track of things.

With a couple of Excel formula's and we can find out exactly who owes what:

=(SUMIF(Table1[Owner],"Joint",Table1[Amount])/2)+(SUMIF(Table1[Owner],[@People],Table1[Amount]))

In my example above, we'd have 2 additional cells in our sheet with the formula calculating that Dan owes 450 whilst Mrs Dan owes 280

That's all pretty cool if this was the 90's and everyone still ran Windows 95. But it doesn't solve our main issues and that is:

• How do we update it easily?
• How do we get reminded to pay it?

Enter Nextcloud...

We're not running Windows 95 anymore. We're running beefy AlmaLinux 8 servers with Docker. So how can I leverage that to allow me to update this from many machines.

For this, I use my Nextcloud container.

Nextcloud is a system that is similar to Dropbox or Google Drive. It's a system where changes can be made to a file on the local machine and these changes will get automatically uploaded to the Nextcloud server. Changes that are made server side are also synced locally back to the machine. I like to think of this concept almost like if IMAP and FTP had a baby except it all runs over HTTPS instead.

In my case, I would use this as one central location for my spreadsheet that can be accessed via my phone's native "Files" app whilst also appearing as a document on my computer. The easy part about this is that no matter which company contacts me to tell me that a bill has changed and no matter how they contact me, I can always ensure that I can update the spreadsheet with the correct information.

Consider the following:

You're in a car shop looking for a new car. With this system, you know how much you pay for your current car. You know how much you pay for all of your other bills. You know with a single change in an excel cell exactly what you would be paying in total if you bought the car and if you did buy the car, you could save the change to ensure that you're reminded to pay the bill upfront after pay day.

All sounds great so far, but how do we remember to pay it after payday?

Enter Node Red...

Onto the reminder system, I used Node Red. It's a graphical system for arranging predefined function blocks that execute specific tasks. The Node Red flow I used for my reminder looks like so:

To explain this, the first part of the flow is a essentially a cronjob with specific formula's for mine and my girlfriend's payday. Whilst my payday is fairly regular, Mrs Dan's payday seems to be based on the whim of the finance team that week. Generally however it more or less the last working day before the 21st of the month so it can be entered programmatically.

Once the schedule is triggered using the Telegram chat ID as the ID for each person, the system will then query this information against a very basic JSON object (very crude I know) which also contains which excel cell the total value for each person is location on the spreadsheet.

The cell is then queried for it's value by taking the formulaic cell value directly from the spreadsheet. This is then formatted into a payload and sent directly to the Telegram user who's payday it is. A very basic but very reliable system for monthly bill's updates via a push notification.

This can also be queried manually by typing "/bills" to the telegram bot.

Once the alert comes through Telegram, the recipient can then log into the mobile banking and proceed with the transaction for the correct amount. The left over money is disposable income.

Closing Thoughts

This system is a very basic but surprisingly reliable solution to an organization problem. It's an easy way to relieve the mind of the stresses of managing bills.

My university lecturer once gave me the advice to "program your future self" as if your future self was some sort of zombie with no decision making capability. We're not always 100% switched on all of the time and sometimes we need to be told what to do, even if this is by our past self. To think about what bills need to be paid and when only serves to cause headaches and stress.

However to allow an automated system to manage this process for us means that we can take the lazy approach of ensuring that the money ends up in the right place at the right time and leaving the rest to pre-planned actions.

Future Plans

For the future, I've looked into ways to automate this further but as you can imagine, banking system's APIs are fairly locked down. For example, the Open Banking API allows you to be logged in but the log in only lasts a few months before you need to authenticate again. You also need to authenticate every transaction and the API is generally overly complicated and inaccessible to the general public without some FCA registered middleman system - so much for being "open"

There is one company however that do offer a potential silver lining to this issue and that is Monzo. Monzo appear to offer you standard run of the mill REST API which can be used to query accounts and to move money into "pots". Not quite as good as moving money into different accounts but this pots idea might work. Is it enough for me to switch current accounts?

This means that the system might at least be able to send follow up reminders if the money hasn't been transferred with the ultimate goal of making the process as automated as possible. If only....

To start with this blog, I think it might be worth talking about this specific project; the website you are currently on.

To start with the basics, the server is hosted behind Cloudflare which I rate highly even just for it's API controlled DNS functionality. The server itself is a small virtual machine in some datacenter halfway across the world. It's quite cheap and as projects go on, I might find some way to take the whole thing "serverless".

I find myself planning on what a page on my new site might contain. I imagine a "Code Snippet" might be pretty cool. A highlight of all of the Docker Compose iac or something? How do I even write a Code Block on Ghost?!

  
    I find myself trying to figure out how to write a code block. This one looks somewhat plain.
    
    Not to worry, it seems as though there's a tutorial I can follow:
    https://ghost.org/docs/tutorials/code-syntax-highlighting/
  

^ This one is just some HTML. It's not even that intuitive.

The guide above says to use 3 backticks. Similar to markdown I guess:

def hellocodeblock():
    print("Hey Look, it's a code block")

Docker Compose

With that out of the way, lets get into some Docker Compose. I generally will launch most of my projects using Docker. The reason? It's easier to clean up when I don't want it anymore and i change my mind a lot.

Lets say one day, I want to switch a service I'm running. In my example, I don't want to use Keycloak anymore because I find it too overkill for my purposes. I want to swap it out for Authentik (more on this in a later post), can this even be done easily without Docker? Apt/Yum remove? What about left over files...

For this reason, I like to put all of my code into Docker and I use Docker Compose for the deployment. For this site, here is the code:

---
version: '3.1'

services:

  ghost:
    container_name: ghost
    image: ghost:4-alpine
    restart: unless-stopped
    ports:
      - 3008:2368
    volumes:
      - /opt/docker/ghost:/var/lib/ghost/content
    environment:
      database__client: mysql
      database__connection__host: mariadb
      database__connection__user: DATABASE_USERNAME
      database__connection__password: DATABASE_PASSWORD
      database__connection__database: DATABASE_NAME
      mail__transport: SMTP
      mail__options__host: MAILSERVER_IP
      mail__options__port: 25
      mail__options__auth__user: EMAIL_USERNAME
      mail__options__auth__pass: EMAIL_PASSWORD
      mail__from: Dan Jackson Ghost <EMAIL_ADDRESS>
      url: https://danjackson.me
    networks:
      - MySQL_Connect
      - frontend
networks:
  MySQL_Connect:
    external: true
  frontend:
    external: true

You might notice above that I've created a bridge network called frontend and you might wonder why. The answers to that question are found here

I've got another network called MySQL_Connect. This is specifically to hold the connection to the MySQL database. The network is specified as internal only and is used to allow traffic to transmit between a single database instance on the Docker host. The MySQL container is not connected to any externally facing Docker network by design and therefore can only be accessed by other containers for additional security.

Reverse Proxy

Infront of every good HTTP based Docker system, there is some sort of reverse proxy to direct the traffic. In my case, despite years of using Nginx, I've now switched to Caddy 2 for all of my traffic.

Why?

Painlessly easy for automated SSL.

Don't get me wrong, you can use both Certbot and Acme.sh for SSL certificates on Nginx. Both solutions support DNS validation too. These are both fairly easy but they both lack a certain instant automation. On Caddy 2 however, it couldn't be more easy. You simply add your Cloudflare API key to the Caddyfile and then define a domain

Here is that config:

{
    # email to use on Let's Encrypt
    email EMAILADDRESS

    acme_dns cloudflare SUPERSECRETAPIKEY
}
### SNIPPITS ###
(webconf) {
  encode gzip
}

(theheaders) {
    header_up X-Forwarded-Ssl on
    header_up Host {host}
    header_up X-Real-IP {remote}
    header_up X-Forwarded-For {remote_host}
    header_up X-Forwarded-Port {server_port}
    header_up X-Forwarded-Proto {scheme}
    header_up X-Url-Scheme {scheme}
    header_up X-Forwarded-Host {host}
}
danjackson.me {
   reverse_proxy http://127.0.0.1:3008 {
      import theheaders
    }
import webconf
}

...I probably don't even need the headers bit.

That's the basis of this Ghost installation. Following the above, I simply point ensure that Cloudflare is pointing at the right server.

Improvements

If you stumble across this and think you want to try this yourself, there are a couple of things with this that can be fixed. For example:

reverse_proxy http://127.0.0.1:3008

There's nothing wrong with this Caddy code, however since both Caddy and Ghost are both in the frontend network, I don't need to open the port forwarding on the host AND I don't need to specify an IP address here, the container name would simply be enough.

Until next time.