TPTito Pinardo Gutiérrez
← Back to the rack
Español
1U · OBSIDIANVault · Git · postmortems In production

Slot 8 of 25 in the rack · In production

1U unit · Documentation

Obsidian · the homelab's memory

Every incident, with its postmortem

Every change, failure and decision on the server is written here: what was done, with which commands, what came out and why. The notes are versioned in Git on their own and Hermes reads them to answer «what happened with…?» questions.

Why so much
If it isn't written down, next time it gets investigated from scratch. Documenting the real output of each command is what makes a failure take minutes the second time.
How it's organised
Ten numbered sections: start, infrastructure, services, status, projects, procedures, history, personal, study and templates. Each note links to the ones that explain it.
Who reads it
Me; Hermes, which has it indexed by meaning; and this site, whose content came from here and was cleaned before publishing.
  • 10numbered sections
  • 18interactive infrastructure maps
  • 13 dayswithout a backup, found by a review
  • 10 minbetween automatic commits

Its code, in the open Public version of the repo: no IPs or secrets.

Inside the documentation

Everything I do on the server ends up here, and much of this site comes from here. Pick a flow.

Flows Pick one and follow the packet.

Outside Obsidian container · Proxmox remote desktop on Docker The app The vault Backup in Git Who reads it Browser Internal door AI agents Private GitHub Second copy Hermes Qdrant Web desktop Obsidian Plugins Safe mode Sections Postmortems Maps Home Auto-commit Local repo SSH key Check Me Procedures Embeddings This site
Hermesvisiting the unit

Click a part or pick a flow. If you came from a skill, the parts where I use it are already lit.

      I write a note
      1. My browser — I open Obsidian from the browser.
      2. Internal door — The internal door checks I'm at home and asks for two-factor.
      3. Remote desktop — The remote desktop is served in the tab.
      4. Obsidian — I write in Obsidian.
      5. Ten sections — The note goes into its section.
      6. Automatic backup — After 10 minutes, the plugin commits.
      7. Vault repository — The history keeps the change.
      8. Push key — With the key kept in the persistent path…
      9. Private repository — …it's pushed to the private repository.
      10. Second copy — And to the second copy inside the house.
      After a failure
      1. The agents I work with — I fix something with an agent's help.
      2. Incidents and postmortems — The postmortem is written with the real commands and output.
      3. Procedures — The affected procedure gets updated.
      4. Vault repository — Commit.
      5. Private repository — And push.
      Hermes searches the documentation
      1. Hermes — Someone asks what happened to a disk after a power cut.
      2. Vector database — Hermes searches the vector database.
      3. Embeddings — The question, turned into a vector.
      4. Incidents and postmortems — The blackout postmortem shows up.
      5. Embeddings — With its most relevant fragments.
      6. Vector database — Ranked by similarity.
      7. Hermes — Hermes answers with a link to the note.
      The backup stops without warning
      1. Automatic backup — The plugin stops committing, with no visible error.
      2. Check the last commit — Checking, the last commit is 13 days old.
      3. Vault repository — Nothing was missing from the repo: there were more notes on disk than in the last commit.
      4. Push key — The key and connection worked: a manual push from inside the container went through first time.
      5. Private repository — The backup, up to date again.
      From note to this site
      1. Ten sections — Notes on projects, incidents and decisions are this site's source.
      2. Me, next time — They're rewritten for an outside reader and cleaned: no addresses, internal names or secrets.
      3. This site — And they end up in the pages you're reading.

      1. My browser

        I open Obsidian from any computer at home, like a web page.

      2. Internal door

        Only from home or the VPN.

      3. The agents I work with

        When I fix something with an agent's help, the postmortem is written with the session's real commands and output.

      4. Private repository

        Where the vault is pushed. Private: it's working documentation.

        • Git

      5. Second copy

        Another repository, inside the house, updated at the same time.

        • Git

      6. Hermes

        Reads the documentation to answer. It never writes to it: my decision.

      7. Vector database

        Where Hermes stores the notes in chunks to search them by meaning.

        • LLM locales (Ollama, Qdrant, RAG)

      8. Remote desktop

        Obsidian is a desktop app. On the server it runs inside a desktop served through the browser.

        • Docker

      9. Obsidian

        The app, in a Docker container with the vault mounted from outside.

        • Docker

      10. Plugins

        Queries over the notes themselves, tasks, calendar and the Git backup. The newest ones are the first suspects when something breaks.

      11. Restricted mode

        Start without community plugins: the way to keep using the vault while looking for the guilty plugin.

      12. Ten sections

        From 00 to 09. Every note in its place with a link to its section.

      13. Incidents and postmortems

        Symptom, step-by-step diagnosis with its reasoning, cause, fix and how to spot it next time.

      14. Interactive maps

        Eighteen infrastructure diagrams explored inside Obsidian, in an isolated frame with no access to the notes.

      15. Home dashboard

        A note that fills itself with each area's status, open tasks and what's on today.

      16. Automatic backup

        A plugin commits and pushes every 10 minutes.

        • Git

      17. Vault repository

        The documentation's full history. What gets deleted is still there.

        • Git

      18. Push key

        Kept in a path that survives the container being recreated, and referenced from the repository's own configuration.

        • Git
        • Linux / SSH hardening

      19. Check the last commit

        Looking at the date of the last commit now and then is what exposed a stopped backup.

      20. Me, next time

        The first reader: the one who hits the same failure months later.

      21. Procedures

        How each thing is done, with its way back.

      22. Embeddings

        Every note, turned into vectors to find it by what it says.

        • LLM locales (Ollama, Qdrant, RAG)

      23. This site

        Its content comes from here, cleaned: no addresses, internal names or secrets.

      What I use from my skill tree

      Pick a skill: the parts where I use it light up on the map and I tell you what for.

      LXC
      Runs in the server's Docker container.
      Docker
      Obsidian inside a remote desktop on Docker, with the vault and settings on persistent volumes.
      Git
      Automatic commit and push every 10 minutes to a private repository and a second copy, with the key in a persistent path.
      Linux / SSH hardening
      Access only from home or the VPN with two-factor, and secrets always outside the vault.
      LLM locales (Ollama, Qdrant, RAG)
      The documentation is indexed by meaning so Hermes can use it when answering.

      Incident log

      Real failures. Read the symptom, pick the cause you think it was and see how it was fixed.

      1. #1

        13 days without a backup

        18-09-2026 · backup

        Reviewing the documentation, the vault's last commit was 13 days old, even though the plugin was set to commit and push every 10 minutes.

        What do you think was going on?

        Show the fix
        Cause
        Credentials and connection worked: a manual push went through first time. What had stopped was the plugin, right after reorganising the whole vault into numbered folders.
        Fix
        Review the diff, commit the reorganisation (git recognised it as renames) and push by hand from inside the container. Then keep an eye on the plugin doing it on its own again.
        Lesson
        A backup that doesn't warn when it fails isn't a reliable backup. Watch the result (the last commit's date), not the configuration.

      2. #2

        «dubious ownership» and then «Host key verification failed»

        July 2026 · Git

        Pushing the vault failed with two errors in a row: first git refused to work with the repository; once fixed, SSH didn't recognise GitHub.

        What do you think was going on?

        Show the fix
        Cause
        The files belonged to the app's user and git ran as root: git refuses that for safety. And SSH looked for the key and known hosts in root's folder, which is emptied every time the container is recreated.
        Fix
        Mark the repository as safe, store known hosts in the persistent path and tell git which key to use from the repository's own configuration, which lives in the vault.
        Lesson
        In a container, whatever isn't on a volume doesn't exist after it's recreated. The fix has to live where things persist, or be repeated every time.

      3. #3

        Obsidian won't come up after updating

        21-07-2026 · app

        After updating Obsidian, the app stopped starting properly. The container was still alive, with no restarts and no memory shortage.

        What do you think was going on?

        Show the fix
        Cause
        Not fully confirmed: Obsidian doesn't write plugin errors to disk. The suspects were the only two asking for the newest version, one of them the plugin that opens a note full of queries at start-up.
        Fix
        Start in restricted mode, without community plugins, to keep using the vault while isolating the culprit.
        Lesson
        Before looking at the app, rule out the infrastructure layer by layer. And know where each thing keeps its errors: here, nowhere.

      How it was built

      1. July 2026

        From loose notes to a system

        • Obsidian on the server, reachable from the browser.
        • Automatic backup to a private repository.

      2. September 2026

        Reorganisation

        • The whole vault in ten numbered sections, each with an index.
        • Postmortems with real commands and output.
        • Eighteen interactive infrastructure maps.

      3. September and October 2026

        Source for Hermes and this site

        • Indexed so Hermes can search it by meaning.
        • This site's content comes from here, cleaned.

      Decisions (and why)

      • What gets documented

        The real result, not the plan

        A procedure that says what should happen misleads you the day something else happens. With each command's output you can tell data from assumption.

      • Where secrets live

        Never in the vault

        The vault is copied to an external repository. Passwords go encrypted in the Ansible vault or in local files with minimal permissions.

      • Can Hermes write?

        No

        The documentation is for work and has to be trustworthy. A small model writing notes would end up mixing data with assumptions.

      What I learned

      • Documenting real results is what makes the second time take minutes.
      • Watch the backup by what it produces, not how it's configured.

      What's next

      • An automatic warning if the vault's last commit is over a day old.
      • Find the plugin that stopped and decide whether to replace it with a scheduled job.

      Shall we talk?

      I can walk through any of these decisions in detail in an interview.

      Download CV Get in touch ← Back to the rack

      Rebuilt from the vault itself, which is private: no paths, internal names or note contents.