How I Turned Daily Journaling into a Linux Terminal Habit

I used to think learning Linux meant memorizing commands.

That approach did not stick for me.

I would learn a command, use it once or twice, forget it, and then come back later feeling like I was starting all over again. At some point, I realized the problem was not that Linux was too hard. The problem was that I was treating Linux like something separate from my daily life.

So I changed the approach.

Instead of waiting for a big project or a perfect lab setup, I turned something I already do every day into a Linux habit:

Daily journaling.

The idea

I use Obsidian to organize my notes using a PARA-style structure:

• Projects

• Areas

• Resources

• Archives

But instead of only using the Obsidian interface, I started opening and editing my daily notes directly from the terminal using Vim.

No heavy setup. No complicated workflow. No waiting until I felt “ready.”

Just a simple idea:

If I want to get better at the terminal, the terminal has to become part of my normal life.

That small shift changed the way I approached Linux.

What I built

I created a simple terminal-based journaling workflow around Obsidian, Vim, Git, GitHub, and Forgejo.

The setup includes:

• Obsidian for organizing my notes

• Vim for editing daily notes from the terminal

• Bash/Zsh helper commands to reduce friction

• GitHub as a remote backup

• Forgejo running in Docker as a self-hosted Git backup

• A small Bash function that handles syncing based on whether Docker is running

The sync logic is simple:

• If Docker is running, push to both Forgejo and GitHub

• If Docker is not running, push to GitHub only

• When Forgejo is available again, sync back to it later

It is not a massive project.

That is exactly why it works.

It is small enough to use every day, but practical enough to make the terminal feel useful instead of abstract.

Why this helped me learn Linux

Before this, Linux practice sometimes felt like something I had to schedule separately.

Open a course. Watch a lesson. Run a few commands. Close the terminal. Forget half of it later.

But once my daily notes moved into the terminal, the basics started showing up naturally.

I was using commands because I needed them, not because I was trying to memorize them.

I started getting more comfortable with:

• moving through directories with cd

• listing and inspecting files with ls

• editing files with vim

• checking changes with git status

• committing and pushing updates with Git

• writing small shell functions

• checking whether Docker was running

• thinking about local and remote backups

• understanding paths, files, and simple automation

These are not flashy skills, but they matter.

They are the kind of fundamentals that show up again and again in DevOps, cloud engineering, and Kubernetes work.

The real lesson

The biggest lesson was not about Obsidian, Vim, or even Git.

The biggest lesson was this:

Don’t wait for a big project. Turn your daily habits into your lab.

A lot of beginners think they need a powerful machine, multiple virtual machines, cloud credits, or a complicated homelab before they can start learning Linux properly.

Those things can help, but they are not the starting point.

The starting point is consistency.

For me, daily journaling became a practical way to build terminal muscle memory without forcing myself to “practice commands” in isolation.

Every note became a small repetition. Every commit became a small Git habit. Every sync became a small automation habit.

Over time, those small habits started to compound.

How this connects to my DevOps and Kubernetes journey

This workflow later became the foundation for bigger projects.

Once I became more comfortable living in the terminal, it became easier to work with:

• dotfiles

• Bash/Zsh customization

• Git workflows

• Docker

• local development environments

• Kubernetes manifests

• troubleshooting from logs and terminal output

That foundation became important when I started working on Kubernetes labs, including deploying a self-hosted bookmark manager on Rancher Desktop’s embedded K3s.

But the journey did not start with Kubernetes.

It started with a daily note.

GitHub repo

I am documenting the setup here:

https://github.com/Griffindeetox/obsidian-para-second-brain

Final takeaway

You do not need a perfect setup to grow.

You need a repeatable habit.

And if you can turn that habit into a terminal workflow, you are not just learning Linux.

You are building the foundation for everything that comes after it.

For me, that foundation started with journaling in Vim, syncing with Git, and choosing to make the terminal part of my daily life.