Andrew G. Stanton - Wednesday, April 22, 2026

Convenience matters.

That’s not something I’m interested in arguing against.

It’s the reason most tools get used in the first place.

People don’t adopt software because they’ve carefully evaluated long-term tradeoffs around control, ownership, or durability. They adopt it because it works quickly. Because it’s intuitive. Because it solves a problem right now without asking too much in return.

Open the app -> Start Writing -> Click publish.

Done.

That simplicity is powerful. It removes hesitation, lowers friction and allows people to focus on what they actually want to do—write, share, create, communicate—without getting bogged down in setup or complexity.

And honestly, that’s a good thing.

There’s nothing inherently wrong with convenience.

But over time, I’ve become more aware of what that convenience is built on.

Not in a dramatic or reactionary way. Just by paying attention.

I’ve started to ask very carefully:

Where things are stored.
Who controls access.
What happens if something changes.

Most of the time, everything works exactly as expected. You log in. Your content is there. Your account behaves normally. You publish something, and it shows up where you expect it to.

There’s no obvious problem.

That’s the part that’s easy to miss.

And to be clear, this isn’t about blaming platforms.

They’re designed this way for a reason.

Centralization makes it easier to:

• manage infrastructure
• deliver consistent experiences
• iterate quickly
• and monetize effectively

It allows companies to build systems that feel seamless from the user’s perspective.

But that seamlessness comes with an implicit structure:

• identity is tied to an account
• content lives on someone else’s system
• access is conditional, not guaranteed

Most users don’t think about this structure and they shouldn’t have to.

The problem isn’t that users aren’t thinking deeply enough about these things.

The problem is that the only tools that feel simple to use are often built in a way that removes control by default.

So the choice becomes:

• use something easy and give up control
• or use something more complex and retain it

That’s the tradeoff most people encounter, even if it’s not explicitly stated.

And in that situation, convenience wins.

Every time.

Not because people don’t value freedom.

But because the cost of choosing it feels too high upfront.

That’s the part that I think is worth rethinking.

Not rejecting convenience or trying to convince people to care more about ownership.

But asking a different question entirely:

Can something be simple to use without requiring users to give up control?

That question changes the framing.

Instead of assuming the tradeoff is inevitable, it treats it as a design problem.

Because the current situation isn’t the result of some fundamental law of technology.

It’s the result of how systems have been designed.

Convenience has been layered on top of centralization.

Control has been treated as something separate—something advanced, something technical, something optional.

But there’s no inherent reason those things have to be separated.

It’s possible to imagine systems where:

• writing is immediate
• saving is automatic
• publishing is simple

And yet:

• the work is stored in a way the user controls
• the identity is not dependent on a single platform
• the content can exist and be shared beyond one system

In other words, where convenience and ownership are not in conflict.

That kind of system doesn’t ask users to make a philosophical decision.

It doesn’t require them to understand every underlying detail.

It simply works—while quietly preserving their control.

I’m not claiming this is easy to build.

In fact, it’s significantly harder than the alternative.

Because it requires solving for both:

• user experience
• and user authority

at the same time.

It means not relying on lock-in as a strategy.

It means designing flows that feel simple without hiding the underlying reality.

It means being intentional about where data lives, how identity works, and what “ownership” actually means in practice.

That’s a different set of constraints than most modern platforms operate under.

And I’m still working through what that looks like in practice.

Continuum isn’t there yet.

There’s still friction. There are still areas where the experience can be simpler, faster, more intuitive.

But the direction is clear.

Not toward rejecting convenience but toward reclaiming it.

Toward building something where:

• the easiest thing to do is also the safest thing to do
• the fastest path doesn’t create hidden dependency
• and the user doesn’t have to trade away control just to get started

Because convenience matters.

But not if it quietly takes everything with it.