Dev Journal
Dev Journal #1 — Where Software Drifted, and Why Epheme Pushes Back
The Problem We Keep Pretending Isn’t a Problem
Over the last decade, software quietly shifted from something we used to something that uses us. Not through a single decision, but through a thousand small ones:
- every “Sign in with…” button
- every background analytics SDK
- every cloud-only feature
- every “just create an account to continue”
- every service that stores more than it needs
- every breach that exposes data that never should’ve existed
Individually, these choices feel harmless. Collectively, they’ve reshaped the entire landscape of computing. We now live in a world where most tools require identity, most data lives on someone else’s servers, most interactions are logged or monetized, most software is rented rather than owned, and most risk is pushed onto the user, not the vendor.
This isn’t alarmism. It’s the observable trajectory of the industry. And it’s worth asking: How much of this was inevitable, and how much was simply convenient?
The Hidden Cost of Convenience
Centralized, account-based SaaS solved real problems: syncing, collaboration, distribution, updates. But it also created new ones we rarely acknowledge:
- Attack surface expansion — every cloud endpoint is a new doorway
- Data accumulation — information piles up faster than it can be secured
- Identity sprawl — one compromised account becomes a skeleton key
- Vendor lock-in — switching tools becomes a migration project
- Opaque behavior — users can’t see what’s collected or why
- Permanent history — nothing is ever truly deleted
We traded sovereignty for convenience, often without realizing it. The pattern is clear: when software centralizes, users lose control.
Remember When Software Stayed on Your Machine?
Local software wasn’t perfect, but it had one undeniable advantage: your data stayed with you.
If something broke, it broke locally. If something leaked, it leaked nowhere. If a company shut down, your tools didn’t vanish with it. If you wanted privacy, you simply disconnected from the network.
Local-first computing wasn’t nostalgic — it was sane. We’ve drifted far from that sanity.
Why Epheme Exists
Epheme isn’t a rebellion. It’s a correction. A reminder that software can still be local-first, ephemeral, accountless, privacy-respecting, developer-friendly, non-extractive, and simple by design.
Epheme exists because developers deserve tools that don’t demand identity, don’t store unnecessary data, and don’t turn every interaction into a liability. We’re not trying to rebuild the past — we’re trying to restore the parts that worked and combine them with what we’ve learned since.
The Real Risk: Normalization
The biggest danger isn’t surveillance, breaches, or lock-in. It’s the normalization of all three.
When every tool requires an account, we stop questioning it. When every service logs behavior, we stop noticing. When every product is cloud-dependent, we stop expecting autonomy. Epheme’s job is to push back on that normalization — not with fear, but with alternatives.
A Better Path Forward
Empowered developers through empowered software.
Software should give control, not take it. It should reduce risk, not introduce it. It should disappear when you’re done, not follow you around.
This journal will document how we build toward that vision — the decisions, the tradeoffs, the experiments, and the philosophy behind each tool. Not as a manifesto. Not as a marketing channel. But as a record of how we’re trying to build software that respects the people who use it.
Closing Thought
We don’t need to burn down SaaS. We just need to remember that it’s not the only way to build.
Local-first isn’t nostalgia. Ephemeral isn’t a gimmick. Privacy isn’t a luxury. Sovereignty isn’t a niche. They’re foundations worth rebuilding on.
This is where Epheme begins.