I started a blog.....in 2024 (why you should too)
Based on NetworkChuck's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
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?
How does the setup keep personal Obsidian content private while still publishing a blog?
What problem does the transcript solve with Hugo front matter, and what fields are used?
Why do images break in the initial Obsidian-to-Hugo sync, and how is it fixed?
How does deployment get automated after code is pushed to GitHub?
Review Questions
- What specific steps ensure only the intended Obsidian content becomes public on the Hugo site?
- How does the Python script change the relationship between Obsidian attachment paths and Hugo’s static/images directory?
- Why does the transcript deploy the Hugo “public” folder to a separate branch rather than deploying the entire Hugo repository?
Key Points
- 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
Keep the Obsidian vault private by publishing only a dedicated “post” folder and syncing only that folder into Hugo’s content directory.
- 3
Use Hugo front matter (title, date, tags) in each Obsidian note so the generated pages display correct metadata.
- 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
Sync posts with robocopy (Windows) or rsync (Mac/Linux) so Hugo’s content/post stays aligned with Obsidian.
- 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
Automate publishing with GitHub webhooks and a single mega script that runs sync, image copying, Hugo build, commit, and push.