How I Ended Up Starting a Blog

People often say that programming is a career of lifelong learning.

Over a lifetime of learning, you accumulate all kinds of knowledge: the computer science fundamentals you learned in college, domain knowledge gained on the job, new technologies, and your own hard-won know-how.
Eventually, it becomes difficult to keep track of it all by memory alone, and even things you learned just a few months ago can start to fade.

That's why I began to feel a real need for personal knowledge management.
At first, I simply took notes in Word documents and backed them up to Google Drive. Later, I moved to Notion, and now I've settled on Obsidian.

As my knowledge began to grow, so did my desire to share it.
I'm more of a practitioner than a researcher, so my knowledge isn't necessarily original.
But even if something is already widely known, I think it's worth sharing when I've reorganized it in my own way.
I've also been gradually building up experience and know-how through my work as a game server developer. There isn't a huge amount of it yet, but it makes for good blog material too.

There's a saying: "You don't really understand something until you can explain it to someone else."
I once explained the basics of computer science to someone without a technical background, and in the process, I realized there were many concepts I understood only vaguely.
Explaining them helped me identify gaps in my knowledge and work on filling them.

Writing blog posts is much the same. The process gives me a chance to organize and refine what I know.
Whether or not anyone actually visits, the thought that someone might find my posts through a Google search encourages me to write from the reader's perspective.
And I expect that process will help me build a stronger understanding.

Nothing Felt Quite Right

Running a tech blog has actually been a long-standing goal of mine.

I don't think of myself as a perfectionist, but I can be unusually particular about certain things. Blogging platforms were one of them.
I tried Naver Blog, Tistory, velog, Google Blogger, and even self-hosting WordPress, but none of them felt quite right.
I wanted full control over the blog's UI and behavior, but existing platforms came with limitations, and even when customization was possible, it took a lot of time.

This was also one of the reasons I moved my personal knowledge management from Notion to Obsidian: I wasn't comfortable having my data tied to a platform that might eventually shut down.

(This section was a little short, so I fed the whole thing to an AI and used the image it generated.)

Building It Myself

In the end, I had to build it myself.

Once I started thinking about building a blog from scratch, I realized just how many systems I'd need to implement.
A post editor, a database to store posts, tags, login integration, search, static file serving, and so on.

It felt daunting, so I kept putting it off. Then static blogs became popular.
They worked by converting Markdown documents to HTML and serving them, and many people adopted them because they only needed to host static files.
I tried that too, but it still wasn't easy to customize things the way I wanted. Maybe it's because I'm a server developer, but I also didn't like the feeling of not having a backend.

I didn't end up making a static blog, but the experience gave me an idea.
If I could serve Markdown files written in Obsidian directly as blog posts, I wouldn't have to implement nearly as much.
All I'd need to do is read the files from my Obsidian vault, convert them to HTML, and properly index their tags and contents. Then they'd be ready to serve to users.

AI has also come a long way and can now generate code pretty well.
For this blog project, I was able to use Claude Sonnet 4 to vibe-code my way through it.
I describe the look and functionality I want, and it implements the frontend CSS, HTML, and JavaScript along with the Node.js backend.

Of course, I can't just use the generated code as-is. I have to review everything and fix the parts where it misunderstood what I wanted.

Even so, it saved me an enormous amount of time compared to writing everything myself.
Claude wrote the entire frontend, and all I had to do was fiddle with CSS margins to make things look a little better.

How It Works

The actual process is a little more complex, but I'll give a brief overview here.
In the live service, there are additional features, such as throttling when changes are detected.

Writing a Blog Post

I write a blog post in Obsidian.
I add metadata such as tags, the date, and visibility through properties, and upload a thumbnail image.

Processing and Conversion

Obsidian is also installed on the server, and because I subscribe to Obsidian Sync, changes are synchronized automatically.
When the server's Node.js service detects a file change in the vault, it starts the conversion process.

Conversion process

• Translate documents originally written in Korean into English
  • Skip translation if the Markdown file's hash hasn't changed
  • Use the OpenAI API (gpt-4o-mini) for translation
• Convert Obsidian-style tags to Markdown format
  • Convert tags such as image size settings directly to HTML
  • Handle relative and absolute links as appropriate
• Convert Markdown to HTML
  • markdown-it
• Store metadata such as tags, date, and thumbnail in memory
  • node-cache
  • Estimated reading time: reading-time
• Read and index post content for search
  • fuzzysort
• Copy required static files to the service folder

Once conversion is complete, the posts and their metadata are indexed in memory.

Backend Processing

Web requests are served through Express.

• List page: retrieve and send indexed posts
• Post page: send the requested post
• Search API: search posts indexed by fuzzysort and return the results

I also implemented a few additional features for SEO and optimization.

• Generate tags such as hreflang and meta tags appropriate to each post
• Generate files such as sitemap and robots.txt from the information in memory
• Resize and cache images

Frontend Processing

For comments, I used giscus, which is based on GitHub Discussions.

I added Google Analytics to understand how visitors use the site, along with a cookie consent prompt.

Time to Put It to Good Use

Actually, I started a blog once before, about ten years ago.
I decided to run an indie game review blog and put a lot of effort into setting it up. But after publishing a few posts, I gradually stopped.

Maybe it's because of that experience, but even after enthusiastically finishing the code and writing my first post, seeing the empty categories feels a little daunting.
Still, I'm telling myself that this time will be different, and I'm going to try to keep posting regularly.