> ## Content Index
> Fetch the complete content index at: https://blog.claeyscloud.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Blogging as a self hoster
- URL: https://blog.claeyscloud.com/blogging-as-a-self-hoster/
- Published: 2026-09-10T13:55:17.000Z
- Updated: 2026-09-10T13:57:59.000Z
- Description: Running a blog is easy. Owning your content is harder. This is the story of how I moved from WriteFreely to Ghost and ended up discovering that Markdown and Git matter far more than the publishing platform itself.
- Author: David Claeys

For most people, blogging is simply a matter of creating content.  
And to be clear, creating high-quality content is no easy task.

That's exactly how I started. I created a WordPress blog, tweaked the design to my liking, and began writing.

However, a lot of time has passed since then. I've gained a few kilos, lost a bit of hair, and somehow ended up deep in the self-hosting rabbit hole.

For a while, I self-hosted my blog using WriteFreely while mirroring my articles to Medium. I would write everything in Markdown on WriteFreely and then manually adapt each article on Medium to achieve a reasonably decent layout.

This setup worked well enough. I owned my content and had a place to publish it, while Medium helped new readers discover my articles.

When I started the blog, I intended to write concise articles. That's how I ended up choosing WriteFreely.

However, as time passed, I noticed that my articles weren't nearly as short as I had expected. As I published more and more content, browsing the blog became increasingly difficult.

For a long time I searched for alternatives that would suit my needs.  
The platform had to be self-hosted, have a modern design, and support Markdown.

Markdown is the format that WriteFreely uses. At first, I saw it as a limitation, but over time I realized it was actually one of its greatest strengths. Markdown is simple, portable, and non-proprietary. Unlike content locked away in a database or a proprietary editor, a Markdown file can be opened, edited, and migrated almost anywhere.

As a self-hoster, that realization became increasingly important to me. I didn't just want to own the platform that hosted my content; I wanted my content to be platform-agnostic and independent of any particular piece of software.

As a content creator, I had another issue: WriteFreely didn't provide any analytics.

Don't worry, I wasn't planning to become the next advertising giant. Still, after spending several hours writing an article, it's nice to know whether it was read by hundreds of people or just by a few friends and a couple of search engine bots.

That's how I ended up with [Ghost](https://github.com/tryghost/ghost?ref=blog.claeyscloud.com) and [Umami](https://github.com/umami-software/umami?ref=blog.claeyscloud.com).

Yes, Ghost offers a native integration with [Tinybird](https://www.tinybird.co/?ref=blog.claeyscloud.com), but Tinybird is not open source and requires significantly more resources than I was willing to dedicate to a personal blog.

Umami, on the other hand, is lightweight, open source, and easy to deploy. After tweaking a few settings in Ghost (Code Injection), I had self-hosted analytics up and running in just a few minutes.

For the curious, this is what my Docker Compose stack looks like:

```yaml
services:
  ghost:
    image: ghost:latest
    restart: unless-stopped
    ports:
      - "2368:2368"
    environment:
      url: https://blog.example.com
      database__client: mysql
      database__connection__host: db
      database__connection__user: ${MYSQL_USER}
      database__connection__password: ${MYSQL_PASSWORD}
      database__connection__database: ${MYSQL_DATABASE}
      security__staffDeviceVerification: "false"
    volumes:
      - /docker/ghost/content:/var/lib/ghost/content
    depends_on:
      - db
  db:
    image: mysql:8
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
    volumes:
      - /docker/ghost/db:/var/lib/mysql
  umami:
    image: docker.umami.is/umami-software/umami:latest
    restart: unless-stopped
    depends_on:
      - postgres
    environment:
      DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
    ports:
      - "3085:3000"
  postgres:
    image: postgres:16
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - /docker/ghost/umami:/var/lib/postgresql/data

```

At this point, I had the software stack figured out. All that remained was "just" migrating from WriteFreely to Ghost.

Initially, copying the Markdown from one platform to the other seemed perfectly reasonable. After all, I only had a handful of articles.

A few articles later, the process started to become rather cumbersome, and I came to a somewhat uncomfortable realization.

If I got rid of WriteFreely, I would lose access to the original Markdown version of my articles. Ghost allows Markdown to be imported, but once an article is converted into Ghost's editor format, there is no straightforward way to export it back to Markdown.

Suddenly, the format that I had come to appreciate for its portability was at risk of being replaced by content stored inside a CMS. While I would still own the platform, I would no longer have a convenient, platform-agnostic copy of my work.

That's how I landed on my current setup: I write all my articles in Markdown and store them in a Git repository. From there, I can import or publish them to whichever platform I choose.

![Screenshot of my git repository structure](https://images.claeyscloud.com/images/2026/09/10/screenshot-blog-markdown-structure.png)

**Screenshot of my git repository structure*

For Ghost, it's as simple as copying and pasting the Markdown into the editor. Medium is a little more involved, but the important part is that my content remains independent of any particular platform.

Whether I use Ghost, Medium, WriteFreely, or something else in the future, I still own the original source. My articles live as Markdown files under version control, while publishing platforms become little more than presentation layers.

Applications will come and go, but my content remains mine.