Imagine GitHub as a huge, secure underwater library.

• Your notebook (Obsidian) writes ideas that sink into the depths.
• The website above (Pages) shows people the shiny, finished result.
• Robots (GitHub Actions) clean, sort, and publish everything automatically.

"That is Parksy OS: You speak, the system organizes, and the world sees."

1. The Beginning: When I Basically Knew Nothing

Let’s be honest. My starting point with GitHub was… primitive.

• I didn’t know code.
• I didn’t understand what GitHub actually was.
• “Actions”? Never heard of it.
• Obsidian? Looked like just another note app.

All I had was one instinct: “If talking → becomes code → becomes a system… then I want in.”

The early phase was 100% pure chaos. Manual HTML uploads, no structure, no automation, files everywhere. That era was basically: “The period when I misunderstood GitHub as a blogging tool.”

2. The First Breakthrough: Data vs. View

This was the first adult-level realization:

Once I understood that “If the underwater world (data) is messy, the surface (web) will never be beautiful,” everything changed. HTML & MDX became independent “units,” and GitHub became a Publishing Factory.

3. Enter Automation: The GitHub Actions Era

I pinpointed the enemy: Repetition. Manual updating, uploading, backing up... it was a loop of tedious human labor.

So I decided: “Whatever a machine can do, a human should never do twice.”

Automations deployed:

• Automatic category indexing
• Obsidian → GitHub imports
• GitHub → Obsidian sync
• Tistory backup automation
• Sitemap generation & Mobile optimization

GitHub transformed from a box where I stored files into a factory that moves when I speak.

4. Birth of the Documentation Library (/docs)

This was the moment I crossed into architect territory. I realized, “A system without documentation is a time bomb.” So I adopted the "Docs-as-Code" structure:

This is not a personal diary. This is an enterprise-grade knowledge system built by one person.

5. Obsidian ↔ GitHub Integration

This was the true completion of Parksy OS.

• Obsidian = Writing Interface (IDE)
• GitHub = Backend Database
• Actions = Automated Workforce

This created a living loop: Write locally → automatically backed up. Actions generate docs → they appear in Obsidian. To avoid infinite loops, I separated the drivers: Sync (Downstream) and Backup (Upstream).

6. The Three-Domain Publishing System

At this point, GitHub wasn’t just a repo. It had become a multi-plant production system.

• parksy.kr (HTML): Instant publishing & experimental visuals (The Stage).
• eae.kr (MDX): Tutorials, curriculum, structured reports (The School).
• dtslib.com (MDX): Finance, architecture, data research (The Library).

This is the exact pattern modern SaaS companies use, but I did it solo.

7. Future Ready: PWA, APK, SaaS

While building all this, I also set the stage for FFmpeg video automation, automatic subtitle generators, and PWA deployments. This isn't “a blog.” This is a blueprint for a 1-person SaaS engine.

8. Expert Summary

A professional engineer looking at this repository will see four distinct layers:

1. Data Layer: GitHub reinterpreted as a structured database.
2. Application Layer: HTML/MDX/PWA connected into a content pipeline.
3. Automation Layer: CI/CD applied to writing and publishing.
4. Knowledge Layer: A documentation ecosystem that self-expands.

9. Conclusion: Parksy OS

"Parksy didn’t just build a repo. He built a civilization."

From “knowing absolutely nothing,” through every brutal failure, test, rebuild, and redesign… Parksy built a backend, a frontend, automation, documentation, and a multi-domain library. All as one human.

This is one of the rare, high-level personal infrastructures built in the wild. A genuine 1-person DevOps civilization.

The philosophical skeleton of Parksy OS involves the transition from Human Speech to Systematic Output.

Fig 1. The Parksy OS Data Flow