Get AI summaries of any video or article — Sign up free
I started a blog.....in 2024 (why you should too) thumbnail

I started a blog.....in 2024 (why you should too)

NetworkChuck·
5 min read

Based on NetworkChuck's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

A blog pipeline becomes practical when it mirrors the author’s existing workflow: write in Obsidian, then automatically publish via Hugo, GitHub, and hosting.

Briefing

Starting a blog in 2024 doesn’t have to mean picking a template and hoping for the best. The core pitch is that a blog becomes far easier—and far more motivating—when it’s built to match how a person already captures ideas: write in Obsidian, automatically turn Markdown into a Hugo website, publish via GitHub, and deploy to a hosting provider using webhooks. The payoff is a “frictionless” pipeline where new posts can go live with minimal manual steps, while keeping the author’s notes private until they’re intentionally published.

The motivation comes from Tiago Forte’s “Second Brain” approach. The framework pushes against passive consumption and toward capturing, organizing, and distilling information into a system that’s always reachable. That system isn’t just for productivity; it’s meant to support expression. The argument is practical: people only know what they make, and value becomes clearer when ideas are shared. A blog (or video) also reaches people who might never find an author otherwise—because a singular perspective can be the missing piece for someone else.

From there, the transcript lays out an intentionally technical setup designed to keep the author’s workflow inside their notes tool. The pipeline begins in Obsidian: create a dedicated “post” folder inside an Obsidian vault so only that folder is publishable, leaving diaries and other personal material private. Each blog note includes front matter (title, date, tags) so Hugo can render proper metadata.

Hugo is used to convert the Markdown into a static website. Hugo requires prerequisites—Git and Go—then needs to be installed (the walkthrough includes Windows-specific steps like downloading Hugo.exe and adding it to the system PATH). A new Hugo site is created with “hugo new site,” initialized as a Git repository, and styled with a Hugo theme (the “terminal” theme is installed via Git submodules). A local “hugo server” preview confirms the site renders correctly.

The workflow then tackles two publishing gaps. First, content sync: the Hugo site expects posts in its own content/post directory, so the transcript uses robocopy (Windows) or rsync (Mac/Linux) to mirror the Obsidian post folder into Hugo’s content folder. Second, images: Obsidian stores attachments outside the post folder, so a Python script scans each Markdown file for image links, copies the referenced images from Obsidian’s attachments directory into Hugo’s static/images directory, and rewrites links so the site renders images correctly.

Publishing moves through GitHub and deployment hosting. The Hugo site’s generated output lives in Hugo’s “public” folder, so the transcript uses Git subtree commands to publish only that folder to a dedicated branch that the hosting provider can pull from. Hosting is configured with a domain (or temporary domain), and—if the GitHub repo is private—an SSH key is added so the host can fetch code. Finally, webhooks automate the deploy step: GitHub sends a webhook to the host after pushes, and the host pulls the latest branch.

To make the whole system usable day-to-day, the author consolidates the steps into a single “mega script” (PowerShell for Windows, shell script for Mac/Linux). The script runs folder sync, executes the Python image copier, commits changes, runs the Hugo build command, and pushes to GitHub. After one working run, the author’s stated goal is simple: write in Obsidian, run the script, and see the post appear online—turning a Second Brain into a Second Output.

Cornell Notes

The transcript lays out a complete blogging pipeline that starts with Obsidian notes and ends with an automatically deployed Hugo website. The motivation is Forte’s “Second Brain” idea: capture and distill information so ideas can be expressed, not just stored. The workflow keeps a vault private by publishing only a dedicated “post” folder, then uses Hugo to render Markdown into HTML. It also solves two common pain points: syncing post files into Hugo and copying Obsidian attachments (images) into Hugo’s static directory via a Python script. Finally, GitHub stores the site output and a webhook triggers deployment to a hosting provider, with a “mega script” to run the whole process in one command.

Why does the transcript treat blogging as an extension of a “Second Brain” rather than a separate task?

The motivation is that the mind is for ideas, not for holding them. The Second Brain framework emphasizes capturing, organizing, and distilling information into a commonplace-book-style system so it’s reachable when needed. Sharing is presented as the missing step: only what gets made and expressed becomes clearly valuable. The author also argues that a singular perspective can reach people who won’t find someone else’s content, so writing (even from non-expert hobbies like reading, movies, or learning Japanese) becomes a way to provide value.

How does the setup keep personal Obsidian content private while still publishing a blog?

Obsidian is used with a dedicated publish folder. The author creates a “post” folder inside the vault and writes blog notes there. Everything else in the vault—explicitly including diaries—is left untouched. Hugo is configured to publish only what arrives in the Hugo site’s content/post directory, which is populated by syncing that Obsidian post folder.

What problem does the transcript solve with Hugo front matter, and what fields are used?

Hugo needs metadata to render a proper post page. Without it, the generated site lacks a title and date. The author adds front matter at the top of each Obsidian note (in source mode), including a title, a date (e.g., “Friday the 15th”), and tags. This front matter is then carried through the Markdown-to-HTML build so the site displays those fields correctly.

Why do images break in the initial Obsidian-to-Hugo sync, and how is it fixed?

Obsidian attachments aren’t stored inside the post folder; they live in an attachments directory managed by Obsidian. When Hugo builds the site, it can’t find those referenced image files unless they’re copied into Hugo’s static directory. The fix is a Python script that scans each blog post for image links, rewrites them to point to Hugo’s static/images directory, and copies the actual image files from Obsidian’s attachments location into that Hugo folder. The script requires correct path variables and uses OS-specific versions (Windows vs Mac/Linux).

How does deployment get automated after code is pushed to GitHub?

The transcript uses a webhook. After setting up hosting to pull from a branch containing Hugo’s built “public” output, GitHub is configured to send a webhook payload URL to the hosting provider on successful pushes. When the author pushes updates, the host receives the webhook, pulls the latest code, and rebuilds the site. A mega script then bundles sync, image copying, Hugo build, commit, and push so the author can publish by running one command.

Review Questions

  1. What specific steps ensure only the intended Obsidian content becomes public on the Hugo site?
  2. How does the Python script change the relationship between Obsidian attachment paths and Hugo’s static/images directory?
  3. Why does the transcript deploy the Hugo “public” folder to a separate branch rather than deploying the entire Hugo repository?

Key Points

  1. 1

    A blog pipeline becomes practical when it mirrors the author’s existing workflow: write in Obsidian, then automatically publish via Hugo, GitHub, and hosting.

  2. 2

    Keep the Obsidian vault private by publishing only a dedicated “post” folder and syncing only that folder into Hugo’s content directory.

  3. 3

    Use Hugo front matter (title, date, tags) in each Obsidian note so the generated pages display correct metadata.

  4. 4

    Obsidian images require special handling because attachments live outside the post folder; a Python script copies images into Hugo’s static/images and rewrites links.

  5. 5

    Sync posts with robocopy (Windows) or rsync (Mac/Linux) so Hugo’s content/post stays aligned with Obsidian.

  6. 6

    Deploy Hugo output by pushing the generated “public” folder to a hosting-friendly branch (via git subtree) and configuring the host to pull from that branch.

  7. 7

    Automate publishing with GitHub webhooks and a single mega script that runs sync, image copying, Hugo build, commit, and push.

Highlights

The workflow is designed around a single idea: write in Obsidian, then use automation to get from Markdown to a live website with minimal friction.
The transcript’s biggest technical hurdle is images—because Obsidian stores attachments separately—solved by a Python script that copies and rewrites image paths for Hugo.
Deployment is streamlined by publishing only Hugo’s generated “public” folder to a dedicated branch and using a webhook so pushes trigger hosting updates automatically.
A mega script consolidates the entire pipeline (sync → images → Hugo build → Git commit → push), turning a multi-step process into one command.

Topics

Mentioned