Standard Notes is an open-source note taking application available on desktop and mobile platforms that offers end-to-end encrypted synchronization. In other words, all data are encrypted on device before they’re sent to the server to propagate to other devices. I think it’s one of the best open-source note taking products out there with a free plan, at the time of this writing.

That being said, their introductory free tier leaves a lot of be desired. It could work for users with basic note taking needs but if you want to organize your notes in nested folders, use multiple editors like Markdown and Rich text, switch between a variety of themes, or schedule regular backups, you have to go with a premium plan. At $12/month, or $5/month if billed yearly, their cheapest plan is definitely at the higher end of the spectrum, especially that the service isn’t complex enough to warrant the hefty subscription fee in my view. It should come at no surprise if a Standard Notes subscription is considered a quite hard expense to justify by regular users who don’t fiddle with notes on a daily basis, or heavily rely on note taking in a professional capacity.

Fortunately, the Standard Notes team is nice enough to open source all their stack for anyone to self-host for personal use. On top of the obvious benefit of enjoying all the premium features free of charge, self-hosting comes with the advantage of full data control. The official documentation around self-hosting published by the Standard Notes team is clear and straightforward. They put together a docker-compose file that defines the entire stack along with a convenient script to create configuration files, bring the stack up and down, view logs, and more.

Thanks to the power of containers, you can be up and running in a matter of minutes, unless you’re running an ARM chip like a Raspberry Pi. Sadly, Standard Notes don’t provide official Docker images for ARM processors. You can either pick one of the third-party images made available by random users, or build your own. I tend to go with the latter option because it grants more control over the software version packed in the image, and most importantly it obviates the inherent security risk that comes with running untrusted Docker images1. In the next section, we’ll go over the steps to build Docker images from source compatible with ARM processors, or any target architecture for that matter. If the official Docker images work on your processor architectures, feel free to jump straight to the “Premium extensions” section.

Building Docker images for ARM

First, we need to pull the code of the service we want to build a Docker image for. Let’s go with the auth service.

git clone https://github.com/standardnotes/auth

Then, from within the auth folder, let’s switch to the latest tag, or any other target version you want to use:

cd auth
git checkout 1.46.1

If you’re not sure what’s the latest tag, you can either check it directly on Github or list all available tags using:

git tag --list

If you’re building the image on the same machine that’s going to ultimately run the container, all you have to do is run a typical Docker build command like:

docker build -t arm-auth:1.46.1 .

However, if you’re building the image on a separate machine, perhaps because your server doesn’t have enough resources to carry out the build process, you can target a specific CPU architecture using buildx. Here’s what the command would look like:

docker buildx build --platform linux/arm/v6 -t arm-auth:1.46.1 . --load

Here, we’re targeting the version 6 of ARM and tagging the image with arm-auth:1.46.1. If you’re running a different version of ARM make sure to update the --platform flag accordingly.

As a side note, this will only work if linux/arm/v6 is loaded in the current buildx builder. To check the platforms supported by your buildx builder, run:

docker buildx ls

If your target platform is not currently loaded in buildx, try running a binfmt container like the following:

docker run --privileged --rm linuxkit/binfmt:a17941b47f5cb262638cfb49ffc59ac5ac2bf334

Now that the image is built, we need to move it to the server where it’s supposed to run. To do so, we first need to save it in a tar archive using the following command:

docker save arm-auth:1.46.1 -o arm-auth.tar

Then, after transferring it to the server via rsync, a USB key, or whatever other means deemed most convenient, we should load it on the server using:

docker load -i arm-auth.tar

Now, if we list all Docker images using docker images we should see our new arm-auth image. All that’s left to do is reference this image inside the standalone docker-compose file provided by Standard Notes.

It goes without saying that all the steps we’ve gone through in this section would need to be repeated for each one of the official Standard Notes services, which currently are:

On top of their own services, Standard Notes use Redis for cache and MySQL for storage. The latter can be replaced with a MariaDB ARM image like linuxserver/mariadb while the former can be used as is; it already has a Docker image for ARM.

Premium extensions

Once your self-hosted Standard Notes instance is up, you can connect to it by pointing your Standard Notes client to your instance, under the “Advanced” section of the account creation or login view. You first need to create an account, which will be a “Basic” one by default, equivalent to the free tier. To be able to use premium themes and editors you need to upgrade your account with a couple of commands. Unfortunately, having a premium account in your self-hosted instance doesn’t automatically give you access to premium themes and editors. Standard Notes don’t give out their official premium extensions for free but you can load other community-built alternatives. Here are a couple of sources to get you started:

To load an extension, head over to your desktop client under Preferences > General > Advanced Settings. Then, enter the extension URL in the “Install Custom Extension” input field and hit “Install”.

Wrap up

Self-hosting Standard Notes is strikingly straightforward, barring few extra steps that require some Docker knowledge when working with an ARM chip. In this article, we’ve gone over everything needed to setup a Standard Notes server that’s not covered in the official documentation.

If you have any questions or face difficulties with the instructions laid out above, feel free to reach out on Mastodon.

  1. The Docker image could fall out of date and lack crucial security patches; or, more unlikely although not totally impossible, contain malware. ↩︎