This is the story of how I set up this blog from scratch. The whole thing — from an empty repo to a live site with automatic deployments — took a couple of hours. Here’s the plan I started with, what actually happened, and the workflow I ended up with.

The Requirements

I wanted a personal blog with a few non-negotiables:

  • Markdown-based authoring — I write in markdown already, so no CMS
  • Zero maintenance overhead — no servers to patch, no databases to back up
  • Free (or near-free) hosting — this is a personal blog, not a business
  • Custom domain — davletshin.com, which I already owned
  • Google Workspace email preserved — my email runs through Google Workspace on the same domain, and I couldn’t afford to break it during DNS changes
  • No comments — at least not initially
  • Google Analytics (GA4) — basic traffic visibility
  • Room for future subdomains — my son has projects that might live on son.davletshin.com or similar, hosted separately

The Architecture I Planned

After some research, I settled on this stack:

  • Hugo as the static site generator — fast, mature, great theme ecosystem
  • PaperMod theme — ultra-minimal, clean typography, well-maintained
  • CloudFlare Pages for hosting and CDN — free tier is generous, automatic deploys from GitHub
  • CloudFlare DNS — moved from Squarespace Domains (originally Google Domains) for unified management
  • GitHub private repo as the source of truth

The URL structure was important to me: I wanted clean URLs with no /posts/ prefix. So davletshin.com/setting-up-this-blog/ rather than davletshin.com/posts/setting-up-this-blog/. Hugo’s permalink configuration handles this cleanly.

The domain architecture:

  • davletshin.com → Hugo blog on CloudFlare Pages
  • www.davletshin.com → redirect to root
  • son.davletshin.com (future) → separate host (Render, Fly.io, or a VPS)
  • Google Workspace MX/SPF/DKIM/DMARC records → preserved through the DNS migration

Phase 1: Hugo + GitHub

Creating the Site

Standard Hugo setup:

hugo new site davletshin-com
cd davletshin-com
git init
git submodule add https://github.com/adityatelange/hugo-PaperMod themes/PaperMod

The hugo.toml config was kept minimal: site title, base URL (https://davletshin.com/), PaperMod theme enabled, permalinks configured for clean URLs, timezone set to Europe/London.

First Post and Local Preview

hugo new hello-world.md
hugo server -D

Local preview worked perfectly on the first try. Hugo’s live reload is fast enough that you can write in one window and see changes instantly in the browser.

Committed everything and pushed to a private GitHub repo.

Phase 2: CloudFlare Pages Deployment

The Worker Detour (Don’t Do This)

I initially set up a CloudFlare Worker by mistake. Workers are powerful — they’re serverless functions at the edge — but they’re completely wrong for a static Hugo site. The Worker setup doesn’t integrate with Hugo’s build process out of the box, and I wasted time trying to make it work before realising my mistake.

Lesson learned: CloudFlare Pages and CloudFlare Workers are different products for different use cases. Pages is what you want for static sites. Read the docs more carefully.

Pages Setup (The Right Way)

Once I switched to Pages, everything was smooth:

  1. CloudFlare Dashboard → Pages → Create project → Connect GitHub → select repo
  2. Build settings:
    • Framework preset: Hugo
    • Build command: hugo --minify
    • Output directory: public
  3. Environment variable: HUGO_VERSION pinned to a stable version (PaperMod requires v0.146.0+)

The site was live within minutes of pushing to GitHub.

Custom Domain

In Pages → Custom domains, I added:

  • davletshin.com
  • www.davletshin.com (configured to redirect to root)

Phase 3: DNS Migration (The Tricky Part)

This was the most nerve-wracking step because my Google Workspace email runs on davletshin.com. Breaking email to set up a blog would be a terrible trade.

Moving DNS to CloudFlare

My domain was registered through Squarespace Domains (it started at Google Domains, which migrated to Squarespace). To use CloudFlare Pages with a custom domain, I needed CloudFlare managing DNS.

The process:

  1. Added davletshin.com to CloudFlare
  2. CloudFlare scanned existing DNS records and imported most of them
  3. Carefully verified all Google Workspace records were present:
    • MX records — these route email to Google’s servers
    • TXT record for SPF — authorises Google to send on behalf of my domain
    • TXT record for DKIM (google._domainkey) — email signature verification
    • TXT record for DMARC — email authentication policy
  4. Changed nameservers at Squarespace to point to CloudFlare’s assigned NS records

The DNS Hiccup

The setup kept failing initially. Turns out I had legacy NS records still configured in Squarespace from a previous setup. These were conflicting with the new CloudFlare nameservers. Once I deleted the stale records and pointed the nameservers cleanly to CloudFlare, everything propagated correctly.

Email kept working throughout — the key was making sure all MX and authentication records were in place before switching nameservers.

Google Analytics

Added a GA4 property, got the Measurement ID (G-XXXXXXX), and added it to the Hugo/PaperMod config. PaperMod has built-in support for analytics params, so no custom templates needed.

The Publishing Workflow

This is the part I’m most happy with. My actual workflow now:

  1. Do the work — set something up, solve a problem, build something
  2. Ask ClawdBot to draft a blog post based on our conversation history (this is part of a broader self-optimisation loop)
  3. ClawdBot searches through recent chat logs, pulls relevant context, and writes a proper Hugo post with frontmatter
  4. I review and polish the draft
  5. git push to the private repo
  6. CloudFlare Pages picks it up and rebuilds automatically — the site updates in seconds

The key insight: I don’t write posts from scratch anymore. I work on projects and talk to ClawdBot while doing them. When I’m ready to publish, I ask it to use our conversation history as source material. It has access to all the details — what I tried, what failed, what worked — because it was there helping me through the process.

This post itself started as a planning document and a shorter draft. Claude Code merged them, expanded the narrative, and produced what you’re reading now. I reviewed it, pushed it, and it was live.

No manual deployment. No build servers to maintain. Just work, draft, push.

What It Costs

  • Hosting: £0 (CloudFlare Pages free tier)
  • Domain: Already paid for (Squarespace Domains)
  • DNS: £0 (CloudFlare free tier)
  • Analytics: £0 (GA4 free tier)
  • Total ongoing cost: £0

What’s Next

The blog is the first piece of a larger domain architecture. Future plans include:

  • A separate subdomain for my son’s projects, hosted on its own platform (Render, Fly.io, Railway, or a VPS — TBD based on what he builds)
  • The blog stays static and simple; anything dynamic lives elsewhere
  • Keep the separation clean for security and operational simplicity

For now, the blog works exactly as I wanted: low effort, no friction, and a workflow that turns conversations into published posts.