There is a question that most software companies never ask. Who should own the relationship between a person and their own thoughts?

Instead, the conversation tends to revolve around features. Cloud or desktop. AI or no AI. Offline support. Dark mode. Meanwhile, a far more important question often goes unanswered.

Who really owns what you create?

At Noesis, that question shaped every decision we made when building Journalit. Not because we wanted another feature to add to a comparison table but because we believe software should help people become more capable, not more dependent. Local-first wasn't a technical decision. It was a philosophical one.

A Different Starting Point

Over the last few years, local-first has become an increasingly popular term in software. Many products now advertise offline support or local storage as features, sitting alongside export options, integrations and dark mode. We think that misses the point.

Local-first isn't something software does. It's a decision about who the software is built for. If a product assumes your work ultimately belongs on someone else's servers, then your ownership will always have limits. If a product assumes your work belongs to you from the very beginning, every design decision changes. That was our starting point.

Designing Around Ownership

When we built Journalit, we asked ourselves one question repeatedly. If Noesis disappeared tomorrow, what would we want to happen to our users' work?  

The answer was surprisingly simple. Nothing. Your journal should still exist. Your reflections should still belong to you. Years of thinking, reviewing and learning shouldn't disappear because a company changes direction, changes its pricing or simply ceases to exist. Everything else followed from that decision.

Journalit stores your journal locally as plain Markdown files inside your own Obsidian vault. Not in a proprietary database. Not in a format that only we can read. Not behind a subscription. Your work remains yours. Today. Tomorrow. And years from now.

The Cost of That Decision

Choosing local-first wasn't the easiest path. It meant saying no to simpler architectures. It meant accepting technical constraints that many software companies would avoid. Building a traditional web application would almost certainly have been faster. It may even have been commercially easier. But software is shaped by the compromises its creators are willing to make. Ownership was one compromise we weren't prepared to make.

The Deeper Question

The more we've thought about local-first, the more we've realised it points to a much bigger question. What is the relationship between software and the person using it?

Much of today's software is designed to create dependency. Notifications compete for attention. Habit loops encourage constant engagement. Data becomes leverage. Subscriptions become difficult to leave. Not because individual companies are malicious but because dependence is often the business model.

We wanted to build something different. Software that respects intelligence. Software that assumes people should own their own work. Software that quietly helps people think more clearly, then gets out of the way.

More Than a Technical Choice

Local-first isn't a feature. It isn't a pricing strategy. It isn't a marketing slogan. It's a statement about what we believe software should be. Technology shouldn't make people more dependent. It should make them more capable. That belief shaped Journalit. It will shape every product Noesis builds. In the end, the most important thing software can help you own isn't your data. It's your ability to think for yourself.

Reflection

If every company whose software you use disappeared tomorrow, how much of your work, your knowledge and your thinking would still truly belong to you?