The last note taking app you'll ever need

It's deeply satisfying when I can maintain a high level of organization and productivity in my life. So naturally, I'm intrigued by the single file productivity systems developers have been making [1] [2]. Obsidian is also a massive inspiration with its linked notes and plugins like Dataview.

The simplicity, flexibility & centralization of these systems speak volumes to me for saving my todo lists, notes about things I've read and the like. However note-taking apps such as Obsidian, which are closed source, felt finite and restricted.

Concerns around vendor lock-in are why I created my own notes system. I've been using it as my core productivity framework for the past year and it's become indispensable to my work. Having the freedom to create custom tooling and integrations has impacted my day-to-day, and I’m excited to keep exploring its potential.

Features for the note taking app detailed in this guide include:

• Self-hosted

• Private

• Built to last

• Low maintenance

• Access in one place & from any device (Obsidian charges for this feature)

• Versioning

• Zero vendor lock-in

• Extendable (eg. passing text-embedded notes to AI)

The digital hoarder

Saving your notes digitally has many benefits. One being improving searchability across a corpus of notes. Now with advances in AI - notes saved digitally have the ability for smart categorization, summarization & more.

Saving anything online comes with a few points of concern. Privacy and provider lock-in are the most frequently discussed. Not to mention ensuring your notes don't get yeeted into the abyss when your computer stops working.

While these concerns are worrisome, they aren't enough for the mass population to go analog and use physical journals like it was the 1970s.

Easier than you think

I've used Directus to go from 0 to 60mph to build a secure, flexible and easy to use notes web application. Don't worry we're not locked into using Directus. The database and data inside it are yours to port how ever you wish in the future.

Directus is an open-source data platform built by Benjamin Haynes. It provides a real-time API and intuitive no-code interface for managing SQL database content. No paid affiliation, just a fan of the platform.

Let's dive into the setup.

1. Hosting your app

You'll need a place to host your dockerized Directus app to start. For those without their own VPS - I've written an article here on the cheapest way to host your own web apps.

Optionally, there's Fly.io or Railway which make hosting web apps easy. Though there are trade-offs to hosting on these sort of providers as they are likely not long lived. At the time of writing neither Fly.io and Railway have Docker Compose support so your set up will look slightly different than this guide outlines.

2. Hosting your database

We'll need a place to save our notes data into a database. Directus allows you to use a variety of SQL databases such as PostgreSQL and SQLite. In this guide we'll use PostgreSQL.

I initially started with a $15/mo managed postgres instance from Digital Ocean for a few months. Then moved to a containerized postgres instance I self-manage and backup.

Use the option which makes the most sense for you.

3. Update app config

Use the docker compose yaml code below to start from. Its config is using a containerized postgres instance that our notes app can use to store it's data. It also uses a containerized redis instance for caching.

For those with managed databases - comment out the database service & postgres_data volume then update the database config in the directus service to use your managed database credentials.

yaml

    version: "3"
    services:
        database:
            image: postgres:15
            container_name: my_postgres
            restart: unless-stopped
            environment:
            POSTGRES_USER: "directus_user"
            # Add secure password here
            POSTGRES_PASSWORD: ""
            POSTGRES_DB: "directus_db"
            volumes:
            - postgres_data:/var/lib/postgresql/data
            ports:
            - "5432:5432"
            networks:
            - directus

        cache:
            container_name: cache
            image: redis:6
            networks:
            - directus
            restart: always

        directus:
            container_name: directus
            image: directus/directus:10.8.3
            ports:
            - 8000:8000
            volumes:
            - ./uploads:/directus/uploads
            networks:
            - directus
            depends_on:
            - cache
            restart: always
            environment:
            # Add key and secure secret
            KEY: ""
            SECRET: ""

            # Add your email & secure default password here
            ADMIN_EMAIL: ""
            ADMIN_PASSWORD: ""

            # Add your email to EMAIL_FROM and EMAIL_SMTP_USER
            EMAIL_FROM: ""
            EMAIL_TRANSPORT: "smtp"
            EMAIL_SMTP_HOST: "smtp-relay.brevo.com"
            EMAIL_SMTP_PORT: "587"
            EMAIL_SMTP_USER: ""
            # Add secure password here
            EMAIL_SMTP_PASSWORD: ""


            # Uncomment below - for S3 file store
            # STORAGE_LOCATIONS: ""
            # STORAGE_DIGITALOCEAN_DRIVER: "s3"
            # STORAGE_DIGITALOCEAN_ROOT: "/"
            # STORAGE_DIGITALOCEAN_BUCKET: ""
            # STORAGE_DIGITALOCEAN_REGION: ""
            # STORAGE_DIGITALOCEAN_ENDPOINT: ""
            # STORAGE_DIGITALOCEAN_KEY: ""
            # STORAGE_DIGITALOCEAN_SECRET: ""

            # This uses postgres for database
            DB_CLIENT: "pg"
            DB_HOST: "database"
            DB_PORT: "5432"
            DB_DATABASE: ""
            DB_USER: ""
            DB_PASSWORD: ""

            CACHE_ENABLED: "true"
            CACHE_STORE: "redis"
            REDIS: "redis://cache:6379"

    networks:
        directus:

    volumes:
        postgres_data:

4. Run your app

Its as easy as saving the docker-compose file to your hosting server and running docker compose up.

Once that's running you can login to your app with the ADMIN_ credentials from your docker-compose configuration.

5. Saving your notes

I've created a simple Notes table as shown. I went with Markdown language to save my notes in as it's widely used, has HTML support and multi-decade history.

If versioning is important to you be sure to select enable versioning on your Notes data model.

Ending notes

With this self-hosted notes system, you're now free from walled gardens and have full control over your notes.

As for my own notes app, I'm currently working on a chrome extension to help bookmark and add notes to various articles I'm reading. At some point, I'd like to build my own flavor of Obsidian's Dataview to work with a markdown file using Markdown frontmatter.

If you do create your own notes system using these steps, I’d love to see what you’ve built - especially any plugins or extensions. You can find me at any of the socials in the footer.