Personal Tech Blog / Content Site

The core of a blog is writing, not fighting with tooling. Decide which of these you want:

1. Hand-written HTML: one .html per post, you maintain the index page yourself. Zero dependencies, fully transparent — and painful once you have many posts.
2. Static generator (recommended for beginners): write Markdown, let the tool produce HTML, indexes, archives and RSS. Popular options: Hugo (Go, fastest builds), VitePress (Vue ecosystem, ideal for docs-style blogs), 11ty (flexible).
3. Hosted platform: Medium, dev.to, Hashnode. Easy, but the traffic and the readers aren't yours.

My advice: if you want something that compounds, pick Hugo or VitePress — write .md locally and build the site with one command. Don't spend three days choosing tools. The tool doesn't matter; the writing does.

Once the setup is chosen, build the skeleton:

• Directory conventions: content/ holds your .md posts, public/ or dist/ is the build output (never edit it by hand), and site name / author / navigation live in the config.
• Front matter: each .md starts with metadata — title, date, category, tags, cover image. The generator uses it to group posts automatically.
• Images: put post images in static/img/ and reference them with relative paths. Don't hotlink an external image host — when that host dies, your posts break.
• Categories and tags: few and broad categories (tech / life / notes), many and specific tags (nginx, docker, interviews).

Write one "Hello World" post and run the whole pipeline once. That beats planning ten outlines.

The best part of a generator: configure once, get everything.

Build command (Hugo example):
hugo (for local preview use hugo server -D, it reloads as you save)

It generates for you:

• Home page post list, newest first
• Category and tag pages, aggregated from front matter
• Archive pages grouped by year and month
• RSS: on by default, usually at /index.xml — that's your subscription feed

If you hand-write instead, you still need an index page and an RSS file — generate the RSS XML with a script rather than typing it. The output is plain static files, so any static host will serve them.

A blog isn't only writing — it's keeping people.

RSS: the /index.xml you generated is the feed. Put an RSS icon linking to it and readers can subscribe in Feedly or Inoreader. To aggregate or convert feeds, self-host RSSHub.

Comments (no backend of your own):

• Giscus: backed by GitHub Discussions, free, ad-free, looks best; the repo must be public.
• Disqus: quick to embed, but ad-supported, slow, and flaky in some regions.
• Waline: self-hostable, ships with an admin panel.

I'd use Giscus: fill in a few repo settings and you're done in minutes. Readers can talk to you, and you maintain no database.

You've written locally — now put it online.

Deploy: upload public/ to your server (control panel or plain Nginx), or push to GitHub Pages / Vercel. Vercel connects to the repo and rebuilds on every push; it's the least friction for beginners.

SEO: give every post a meta description and a proper title; submit your sitemap to Google Search Console; add alt text to images.

Distribution: a blog is a long-term asset. Link your other products at the end of posts (sparingly), and capture readers through RSS and email.

Backup: your .md source files *are* the asset. Keep them in Git and push to GitHub — that's an automatic backup, and more reliable than tarballs.