Andrew G. Stanton - Tuesday, March 24, 2026

Convenience is borrowed.
Freedom is owned.

You forget a password.

You try to reset it.
The email doesn’t arrive.
You try again. Locked out.

Maybe it resolves in five minutes.
Maybe it takes hours.
Sometimes it never resolves at all.

Most people don’t think much of it.
It’s just part of using the internet.

But this keeps happening.

And it happens across everything:

• email
• banking
• social platforms
• work tools

At some point, everyone runs into it.

Not just inconvenience — loss of access.

This isn’t a UX problem.

It’s an architecture problem.

Most systems today are built around accounts.

An account is not identity.
It is a record in someone else’s system.

That distinction matters.

Because it means:

• your access can be revoked
• your data can be restricted
• your identity is conditional

You don’t control it.
You are granted access to it.

This works — until it doesn’t.

And when it fails, there is no fallback.

You can’t “recover” identity you don’t own.

You can only request access again.

We’ve normalized this.

We’ve accepted:

• password resets
• 2FA loops
• account lockouts
• support tickets into the void

As if they are just part of how things work.

But they are not inevitable.

They are the result of a specific design:

identity controlled by the system, not the individual

Once you see this, the pattern shows up everywhere.

If your account is suspended:

• your business disappears
• your communication disappears
• your work disappears

Not because you lost it.

Because you never actually had it.

Local-first systems invert this.

Identity is not something you request.

It is something you hold.

• keys instead of accounts
• signatures instead of logins
• local control instead of platform dependency

You don’t ask for access.

You already have it.

This doesn’t remove all friction.

But it removes the most important failure mode:

the ability for someone else to decide whether you can continue

Most people won’t think about this until something breaks.

Until they are locked out.
Until access is gone.
Until there is no one to contact.

By then, it’s too late to redesign the system.

Ownership is not about convenience.

It’s about what happens when things fail.

You don’t have to accept this as fixed.

There are ways to build differently.

Systems where:

• you hold your identity
• your work exists locally
• access is not something you request

This is what local-first makes possible.

It’s not theoretical.

It’s something you can start using, building, and exploring now.

Convenience is great.
Freedom is better.