Origin Log
> BEGIN_FILE: ORIGIN_LOG.TXT
> ROUTING_PATH: /PAGES/ORIGIN-LOG
> PROTOCOL: STRICT_MONOSPACE
> STATUS: COMPILED & LOCKED
Back in July 2022, I founded Mettamaker to build tools for human connection—a mashup of "Metta" (loving-kindness) and "Maker" (systems engineering). I filed the LLC paperwork, designed the 6-block logo and core characters (using my family and our pets as the physical avatars for foundational concepts like mindfulness and metta), spun up a website, and even manufactured a custom hoodie. Then I tried to solve my family's cognitive overload the way any SWE would: I put on my hoodie and began prototyping an app—a digital “vibe journal” to act as an emotional telemetry dashboard.
Then life got in the way.
Even though I wasn't actively building, the architecture kept brewing in the background. When I picked the project back up recently, I still assumed it would eventually need a digital interface. But as I mapped it out, I hit a hard realization about the UI: you can't process unstructured emotional data on a glowing screen. When a kid (or a parent) is experiencing an emotional system crash, the modern reflex is to hand them a screen. It seems to work, but it is just muting a critical system alert with a dopamine spike. Handing them a digital rectangle doesn't process the error; it just adds more noise. Digital interfaces lack the tactile friction required to actually reset a human nervous system.
So I pivoted to analog. I shifted our entire focus to physical infrastructure. Our core offline system is structured exactly like a traditional tech stack, just executed on paper:
├─ [ OS ] Analog OS: A system of mechanical constraints designed to install baseline Decent, Nice, and Reasonable (DNR) protocols, safely routing runtime anomalies before a total cognitive crash.
├─ [ HW ] The Terminal Pad: A 4.25" x 5.5" tear-away notepad built on a rigid chipboard backing, serving as a real-time analog telemetry collector.
├─ [ UI ] 5mm Dot-Grid: A pre-configured interface so exhausted users don't have to burn cognitive RAM designing their own routing architecture during a crash.
├─ [ LOGIC ] 4-Step Routine: An event-handling routine for both system crashes and gratitude, passing through sequential variables (Ping, Route, Cache) before culminating in a final SYSTEM.HALT.
└─ [ DOCS ] Spark’s Big Debug: A 32-page operating manual disguised as a children's book. It introduces the core system commands used to trace any glitch and log daily insights and gratitude. I specifically wrote this first volume to debug the Imposter Glitch—the exact bug that consumed most of my own bandwidth for years.
The Background
My boot sequence was unconventional. An early, unchecked knack for computers drew a visit from the FBI in middle school. I eventually dropped out of high school—bypassing the GED entirely—because I couldn't tolerate the arbitrary, low-EQ authority of the administrators. The system didn't make sense—it was obsessed with control rather than actual optimization.
After a few years of drifting and exploiting community college loopholes, I enlisted in the Army. Part of it was hoping it would provide some discipline—I had internalized the narrative from the adults around me that I was a problem for not fitting into their rigid boxes. Part of it was pure pragmatism: my dad was a mechanic and my mom was a medical lab tech, and they were already stretching to support my older sister at UPenn. I refused to be an additional financial burden. But I quickly found the military was running the exact same legacy software: massive bureaucracies with zero error-handling for human nuance.
So, while still on active duty, I busted my butt to find a better environment. I worked my military day job, went to school at night, and knocked out my MCSE. I earned my Information Systems Management degree (UMUC) just months after my enlistment ended.
I chased the dot-com dream first, trying to launch a couple of scrappy ASP services—including one with my old MCSE instructor. I picked up a Citrix CCA on the fly just to build the infrastructure, doing all the tech, wearing every hat imaginable, and holding onto half-ownership of absolutely nothing. I even designed a brochure for a local restaurant just to bring in some cash. But the real education wasn't technical; it was watching the same low-EQ behavioral glitches I’d seen in high school and the Army play out all over again. Between founder ego trips and partners double-crossing each other over equity that didn't even exist, the human hardware was crashing everywhere. It was a structural bug I would eventually see at every tier of the industry—all the way up to Google.
In the background, I kept upgrading my skills and hammered out my MCDBA. But when my parents hit financial trouble, that chaotic startup hustle wasn't going to cut it. I needed a “real job” to support them, so I leveraged that cert and my hands-on database experience to land a quiet, stable career as a full-time Database Administrator—eventually adding an OCP to the stack once I settled in.
That detour got me a recruiting call from Google to manage their SQL Server databases. While there, the manager for the old Blogger platform asked for help maintaining and performance-tuning his databases. I jumped in, we built a rapport, and I told him I wanted to write code. He gave me some starter projects to prove I could execute, and after I delivered, he ultimately sponsored my official transfer onto the team as a Software Engineer.
Having hacked my way into a SWE role without a traditional CS degree—and bypassing the standard Google engineering interview loop—meant I was constantly measuring myself against the Ivy League pedigree my sister and my new peers shared. But looking back, the friction wasn't just about credentials; it was an API mismatch. I was wired to process behavioral and emotional data in an environment optimized strictly for technical outputs. Emulating the default corporate OS burned massive amounts of cognitive RAM, fueling an Imposter Glitch that ran constantly in the background. I had always run a high-resolution background diagnostic on my own mind, but that didn't make me immune to the bugs. It just gave me a front-row seat to watch my own runtime errors execute in real time.
At the same time, I started noticing a massive blind spot in the environment itself. While everyone else was focused purely on the technical, my radar was tuned to the behavioral. I wondered why an industry obsessed with optimization didn't prioritize the same human telemetry. Google was just starting to experiment with this internally, and when an announcement for their Search Inside Yourself (SIY) program crossed my radar, I immediately signed up.
During a 1:1 "Just like me" practice—a simple exercise designed to recognize shared human struggles—I partnered with a highly driven product and business specialist. Because she wasn't an engineer, my Imposter Glitch didn't immediately spike—I didn't have to worry about a fellow SWE blowing my cover. That unexpected safety allowed me to temporarily drop my armor. I realized this incredibly competent person sitting across from me was carrying the exact same messy, chaotic internal data that I was.
I already knew that on an intuitive level, but sitting there across from her, it was a deeply insightful moment: We all glitch. It isn’t just founders fighting over equity or SWEs battling imposter syndrome. It’s the road-raged commuter, the hangry shopper, the exhausted parent. The system crashes are universal. Human hardware is inherently messy, and most of us are just walking around without the proper error-handling routines to maintain a DNR baseline under a heavy load.
That first SIY course sparked a desire to dig deeper, leading me into intensive Vipassana meditation to understand the backend of this process. I felt a strong pull to help people install that DNR baseline, so I volunteered to be part of the very first cohort of internal facilitators for the SIY program. I participated all the way to the end, but when it came time to schedule our first live sessions, the instructor gently suggested there might be better ways for me to support the program behind the scenes. Honestly, we both knew I wasn't ready. It was a mutual conclusion, but it was still a brutal reality check. I had hit a hard hardware bottleneck: public speaking simply didn't come naturally to me, and my nervous system wasn't calibrated for that kind of load yet.
Getting rejected from the frontend of mindfulness stung, but it forced an architectural pivot. I abandoned the UI and pushed entirely into the database. I had already logged the prerequisite shorter retreats, so in 2015, just before my son, Magnus, was born, I took a sabbatical from Google to sit a one-month silent Vipassana retreat at Spirit Rock to completely strip down my own cognitive framework.
What emerged from that refactoring was a core operating philosophy: If everyone is glitching, frustration is a waste of bandwidth. The only logical engineering response is to take ownership of the infrastructure. You are the architect. Build kind systems.
That philosophy had to survive outside the lab. When I walked away from Google in 2017, I needed a hard reset before I could architect anything new. We immediately prepped a vintage VW Vanagon and launched a 48-state road trip—though navigating a vintage van with a two-year-old and pregnant partner was more like a high-friction system load test.
Once the RAM was finally cleared and I was home full-time, the daily load on the local network spiked. I had always seen those exact same glitches play out in my own living room—navigating major family crises and the long-term friction of my decades-long partnership with Ngan. But compounding that historical data with the daily intensity of parenting meant there was nowhere to hide. Love doesn't prevent system crashes. When the household friction spikes, you still need a routing protocol to process the unstructured data.
I couldn't find that system anywhere, and the entrepreneurial itch to build it myself kept growing as I began to figure out what Mettamaker would become.
> END_FILE
