The Friction You Forgot Existed

You never think about SSL certificates anymore. That's the point.

Ten years ago, putting HTTPS on a website meant choosing a certificate authority, paying annual fees, navigating validation processes, configuring renewal calendars, and debugging expiration failures when you forgot. If you ran a small site, you probably didn't bother. Security was for organizations with budgets.

Let's Encrypt changed that with a single insight: the friction wasn't the certificate itself—it was everything around it. Validation could be automated. Renewal could be automated. Payment could be eliminated. One command, one answer to a challenge, and you had encryption that renewed itself forever.

They issued their first certificate in September 2015. By March 2016, they'd hit a million. By 2020, a billion. Today they issue ten million certificates daily. Global HTTPS adoption went from under 30% to 80% in five years. In the US, it's now 95%.

The Invisible Infrastructure Pattern

Here's what's worth noticing: the success metric for infrastructure like this is that people forget it exists.

Before Let's Encrypt, every technical person had certificate horror stories. Expiration surprises. Validation headaches. The scramble when a certificate lapsed on a production server at 2 AM. Now? Most developers have never dealt with any of that. The problem is so thoroughly solved that it doesn't register as a problem.

This is the Build Once, Use Forever principle at its cleanest. Someone solved certificate management once—properly, with automation—and now 500 million websites benefit without doing anything. The capability became invisible because it became complete.

But invisible success creates a strange problem: gratitude erodes. When friction disappears entirely, people assume it was never there. Let's Encrypt now struggles to fundraise because users don't remember what they're being protected from. The infrastructure is so good that its necessity is forgotten.

What Else Could Disappear?

The pattern invites a question: what current friction could become invisible with the right infrastructure?

Some candidates:

• API key management. Still manual for most projects—provisioning, rotating, storing, revoking. Could be automated like certificates.
• Dependency security scanning. Mostly reactive today. What if it were as invisible as HTTPS—just always on, always current?
• Local development environments. Still hours of setup. The problems are well-defined enough to be solvable.
• Data backup verification. We automate backups but still manually test restores. Why?

The pattern Let's Encrypt demonstrates: if the friction is repetitive, if the steps are knowable, if the failure modes are predictable—it can probably be automated into invisibility.

The Practice

If you're building tools, here's the test: What would complete success look like for this feature? Not "users can do the thing" but "users never think about the thing."

Certificate management reached that bar. The infrastructure became so good that its users forgot it was infrastructure. That's the highest form of solved problem.

The friction you tolerate today might be the friction someone eliminates tomorrow. Or it might be the friction you eliminate—if you see it clearly enough to make it invisible.

Build once. Then watch everyone forget you built it at all.