Problem: when you split things up into different applications, it requires more work from the user to connect their accounts.
For example, The Sample can add subscribers to your newsletter, regardless of what newsletter platform you’re using. If you use the Zapier integration, it’s not too inconvenient: you just hit the “Connect to Zapier” button; pretty easy:
Connecting to Ghost is a bit harder. Ghost can be hosted by anyone, so you have to put in the URL to the Ghost instance you’re using:
You do also have to put in an API key, but that could be more convenient if Ghost implemented OAuth. You’d still have to put in the URL, but after that you could click a “Connect to Ghost” button.
In general, this kind of flow–forcing the user to enter a URL–is necessary if you want to support integration with anyone via protocols (as opposed to integrating only with a fixed number of centralized services). Friction like this can add up. It’s probably not a big deal in the example I’ve shown above, which is sort-of a b2b context, but in a consumer context it would be nice if we could avoid having people fiddle around with URLs.
Anyway, so this seed of an idea I have is that people are already well accustomed to at least one form of decentralized integration–email–and maybe other services could piggy back off of that. Basically, your email provider could maintain a registry of services that you’ve previously connected to and which protocols those services implement. Any time you use your email address to authenticate with a new service, that service can ask your email provider “please give me the URL of a service that implements <some protocol>.” Then the new service can present the user with a “Connect to <some service>” button.
Here’s how this might look in the Ghost example above:
- When you set up your Ghost instance, you enter “firstname.lastname@example.org” as your email address.
- The Ghost instance does a DNS lookup on example.com to see if it supports this “protocol registry” thing.
- If not: then Ghost goes with it’s normal authentication flow (e.g. asks you to choose a password, or sends an authentication link to your email address). The rest of these steps are ignored.
- But if example.com does support the protocol registry thing: then Ghost connects to your email provider via an oauth flow (i.e. in addition to providing a protocol registry, example.com may as well be an oauth identity provider as well). Ghost tells example.com “My URL is <some ghost url> and I implement the Ghost protocol (version y)”.
- Later on, you sign up for The Sample. You authenticate to The Sample the same way Ghost does in step 2.
- The Sample asks your email provider, “Has this person connected to any services which implement the Ghost protocol?”, to which your email provider says “why yes, it’s over at <some ghost url>”.
- Now The Sample can give you a nice little “Connect to Ghost” button, no manual URL entry required.
Again, this probably isn’t a huge deal in this specific example–but on the margin, the more seamless protocol-based integrations can be, the more people can justify building them into their products. I have a few potential use-cases for Yakread which perhaps I’ll write up later.
I guess I’ll at least mention the relation to Grand unified theory of how social media ought to work – at the end of the day, you don’t necessarily want users to have to jump between completely separate websites/apps whenever they want to switch between publishing, reading, or discussion. You’d like to provide a completely integrated, seamless thingy like <every single social media site>. The friction of connecting to external services is a barrier here, and would result in a bias towards services implementing their own functions for publishing, reading, and discussion.
That could still fit with the grand unified theory as long as those functions are still interchangeable: you can publish something with <some service>, but if you decide to instead publish it on <some other service>, it will still be just as visible etc. to people who read on <some service>.
But it does seem like it might be nice if that didn’t have to be the case! With Yakread, I might eventually like to let people write and publish blog posts. Ideally I’d just add a “write” tab (next to the existing “read” tab), with an editor and such. It’d be cool if I could completely outsource the implementation of that to another service (like Platypub) instead of re-implementing the same blogging features that have already been built elsewhere.
OK, well… maybe that’s not a great example, because I could just throw in a “connect to platypub” button which integrates with a centralized service (e.g. at platypub.com). Maybe even have Platypub’s API support creating new users, so the “connect to platypub” thing is unnecessary–when you create a Yakread account, behind the scenes it also creates a platypub account. (And if you already have a platypub account, you can go into the settings and switch/merge). And if you want to use something other than the central platypub instance, you can… go into settings and paste in a URL. .
Maybe this would be more useful for Cross-platform RSS recommendations. Say you want to make subscribing to a newsletter via RSS just as convenient as subscribing via email, and you want to support whatever RSS reader the subscriber happens to use. When the person puts in their email address, you could contact their email provider and ask what RSS reader they use, then pass the RSS/OPML file along to it.
Anyway! I’ll probably come back to this if/when I’m implementing something where this would be useful.