This article was co-written with Claude AI for translation, structure, and technical documentation. It is the fruit of real dialogue and hands-on implementation, not automated content. I wish everyone a good read.
This article is dedicated to my friend Damien Theodorou, the visionary who taught me the concepts of data centralization and introduced me to Obsidian. His ideas were the catalyst for this transformation.
From Digital Chaos to Personal Data Lake: Building an Obsidian-Git Hybrid Architecture
🌍 The Ordinary World: Digital Chaos and Fragmentation
Before this day of July 22, 2025, I lived in the digital chaos typical of our era. My digital life was scattered across an archipelago of disconnected tools:
The fragmented ecosystem:
- Obsidian notes here, WhatsApp there
- Git repositories dispersed without global coherence
- Google Docs for some projects, Word for others
- PowerPoint everywhere: my Komyu resources in one corner, my OpenSeriousGames on openseriousgames.org and in OneDrive
- Emails for quick ideas, different clouds for different projects
The symptom: My professional knowledge from recent years was scattered across multiple identities (Komyu, OpenSeriousGames) and formats (PowerPoint, Word, PDF) that didn’t “talk” to each other.
The suffering of the modern middleware-human: I was losing time searching, manually synchronizing, reconstructing contexts. But above all, I found myself being a human middleware in what could be called “administration of professional and personal data, duties and rights.”
Part of my daily routine looked like this: receive an invoice by email → enter it into accounting tool → update my strategy on Obsidian → present it in pieces on PowerPoint with images → copy-paste to have AI proofread the English → take another file to find someone’s name (taken from LinkedIn in a browser) → schedule a meeting to present all of this.
And even then, all this fragmented workflow was constantly interrupted by competing systems: notifications here, deadlines there, alerts on one side, reminders on the other, opportunities… What cognitive load!
The diagnosis: My time dedicated to interface-hopping had diluted my deep thinking. No more time to challenge assumptions, innovate, not just rely on existing solutions. This “bouncing” multi-interface existence was exhausting, a consequence of having insisted enormously on the technicality of each interface rather than on the substance.
A chronic inefficiency that frustrated me and distanced me from the vision Damien had transmitted: that of a unified system where I could regain my critical thinking in my work, instead of being a simple operator of interfaces and movements that overwhelmed me.
📞 The Call to Adventure: The Architectural Awakening
The trigger came from an apparently simple need: properly structure my Obsidian backup. My vault already contained several Git repositories:
- My personal website
- My educational resources
- Our collaborative repo with Damien
The real stake: This wasn’t just a backup. It was the opportunity to finally materialize the personal data lake that Damien had described to me - this vision of a unified system where everything would be in Markdown and code, LLM-ready, rather than scattered proprietary formats.
As I wrote in my article “What I Learned About Data Strategy Before Going AI-First”: “Nothing we do can be solid without a massive repository where we can tap into all our accumulated knowledge and reflections.”
🚪 The Threshold: Accepting Technical Complexity
First realization: transforming chaos into a coherent system required mastering the hybrid Git-Obsidian architecture. This was no longer a simple backup, but the complete migration of my recent career years to a unified format.
🧙 Allies and Mentors: The Guides of Adventure
Damien Theodorou: The Original Visionary
Damien had planted the seeds of this transformation:
- Personal data lake vision: He had shown me Obsidian and explained why centralizing in Markdown
- Unification philosophy: “Everything must be able to serve each other mutually”
- Active collaboration: Coding partner on concrete AI projects
Claude Code: The Technical Mentor
Claude Code became my implementation guide:
- Analyze my existing structure
- Propose robust solutions
- Help me avoid security pitfalls
- Document the process in real-time
⚔️ The Trials: Technical Challenges to Overcome
Trial #1: The Mystery of Obsidian and .git
The challenge: “Will Obsidian see the .git folders?” Even Claude had doubts.
The resolution: Web search → “File Ignore” plugin → Optimal performance
Trial #2: Nested Git Architecture
The challenge: Having nested Git repos without conflicts
The solution: .gitignore with **/.git/ - simple but powerful
Trial #3: Token Security
The challenge: Clone private repos without exposing tokens The trap avoided: Hardcoded tokens in commands
🛠️ The Implementation: What We Actually Did
Step 1: Initialization
cd "Alex Personal Notes"
git init
git branch -M main
No struggles here - worked first try.
Step 2: The Strategic .gitignore
I created a .gitignore with several important sections:
# Obsidian cache files - CRUCIAL for security
.obsidian/
# Git repositories within - THE key line
**/.git/
# Personal sensitive information - Security first
*password*
*secret*
*key*
*token*
*.pem
# Audio files - My voice notes stay private
*.opus
*.mp3
*.wav
*.m4a
Important security point: .obsidian/ is deliberately excluded. This config contains my personal settings, plugins, shortcuts… No reason to expose them in a backup.
Step 3: Token Management - The Classic Trap
When we wanted to clone the repo-collaboratif (private), Claude almost made the classic mistake: using the token directly in the Git command.
The trap:
# DANGER - Token ends up in bash history
git clone https://ghp_MyToken123@github.com/user/repo.git
What we did:
# Temporary use for cloning, then cleanup
git clone https://ghp_MonToken@github.com/Datheo4ever/notre-repo-collaboratif.git
Then local remote configuration to prevent the token from remaining visible.
Step 4: Initial Commit - The Moment of Truth
git add .
git commit -m "Initial commit: Alex Personal Notes vault backup"
Result: 128 files added! Git properly took all contents without sub-repo metadata. Exactly what we wanted.
Step 5: Private GitHub Repository
Creation on GitHub: personal-vault-backup (private, obviously)
git remote add origin https://token@github.com/username/personal-vault-backup.git
git push -u origin main
Step 6: Obsidian Plugin - The Performance Solution
We weren’t sure Obsidian would really ignore .git. After web research, we discovered the “Obsidian File Ignore” plugin.
Installation: Plugin installed → Immediate performance → .git folders invisible.
🔄 Workflows That Work
Global vault backup
# Simple and effective
git add .
git commit -m "Update vault"
git push
Specialized project work
# Classic Git workflow, unchanged
cd "3 - Resources/GIT/notre-repo-collaboratif"
git add .
git commit -m "Add architecture article"
git push
🚨 The Misadventure: The Token That Slipped In
End-of-day plot twist: While writing this experience article, I accidentally left my real GitHub token in a code example!
What Happened
Wanting to be authentic about the commands used, I copy-pasted the real command with the real token ghp_[REDACTED]. The article was committed and pushed to our collaborative repository… with the token inside.
The Discovery and Reflex Action
A security audit a few minutes later revealed the token in the article. Plot twist: Claude Code was interrupted in the middle of this security analysis (tokens exhausted, reload needed).
My reflex: I immediately deleted the GitHub token from the interface, even though there hadn’t been a public push yet and the repo is private. Good lesson: in security, act first, think later.
The Methodical Correction
- Preventive revocation: Token deleted by security reflex
- Article anonymization:
ghp_[REDACTED]→ghp_MonToken - Complete audit: Verification it wasn’t anywhere else
- New token: Generation of a clean token
- Correction commit: This corrected version to clean the history
Multiple Lessons
- Always reread before committing an experience report
- Systematic audit after writing technical articles
- Assumed irony: Writing about Git security and making exactly the error we denounce
- Security reflex: Act quickly even when the risk seems limited
- Technical learning: You can’t build a personal architecture without understanding at least minimally the objects you manipulate
The moral: Even with all precautions, human error remains the weak link. But that’s also what makes this technical adventure human and pedagogical!
🏆 The Reward: Transformation from Chaos to System
The Accomplished Transformation
Before: Chaos, dispersion, proprietary formats, chronic inefficiency After: Unified, collaborative, LLM-ready personal data lake
The Concrete Gains
- Coherence: All my professional knowledge in a unified format
- Accessibility: Instant search across all my resources
- Simplicity: One tool (Obsidian) to navigate everything
- Standardization: Markdown everywhere, no more proprietary formats
- Independence: No more vendor lock-in, Markdown readable by all
- Resilience: Git backup, replication possible
- AI-ready: Usable by Claude Code, Gemini CLI, Cursor, etc.
The Ongoing Migration Process
Every day, I migrate resources according to Damien’s vision:
- Komyu PowerPoint → Structured Markdown
- OpenSeriousGames resources → Unified format
- Scattered notes → Coherent system
- Multimedia content → Integrated transcription (next step)
With each step, my Markdown database of recent career years gains value. As the article on my data strategy writes: “You’re building infrastructure while wondering if it’s worth the effort. Then something magical happens.”
🔄 The Road Back: Accomplished Personal Data Lake
The Final Realized Architecture
A system where everything serves each other mutually:
- Unified search across all my knowledge
- AI that can work on my entire base
- Fluid collaboration with partners like Damien
- Total technological independence
Planned Evolutions: Toward the New World
- Enhanced security layer: Encryption questions to explore (git-crypt? Obsidian Encrypt plugin?)
- GitLab replication: Double backup for resilience
- Audio/video transcription: Multimedia content integration
- Complete Personal Data Lake: Final vision described in my article “What I Learned About Data Strategy Before Going AI-First”
- Skill development: This adventure shows you can’t build a personal architecture without minimum technical knowledge
The exciting horizon: This centralization is just the beginning. I think it will be democratized long-term by beautiful initiatives like MCP (Model Context Protocol), and previously by API designs. Moreover, with Damien, we’re thinking about building our own Komyu product in API-first or MCP-first mode.
This work with Git-Obsidian isn’t just technical practicality - it’s the challenge of making my critical thinking exist in my work and not finding myself being an operator of interfaces and movements that overwhelm me. It’s the new world, and it’s exciting!
What I Take Away
The secret: Respect existing tools and compose them intelligently, as Damien taught me. Git does Git, Obsidian does Obsidian, and both coexist in the harmony of a unified system.
The journey traveled: From scattered digital chaos to a coherent personal data lake, ready for the era of collaborative AI. A small technical adventure that changed how I work.
Architecture implemented on July 22, 2025 - Alexandre Quach
From digital chaos to personal data lake: 128 files backed up, 3 nested repositories, 0 conflicts
“The factory must grow” - applied to personal knowledge
With gratitude to Damien Theodorou for his vision and to Claude Code for the implementation