Systems

Why Don't Our Apps Talk to Each Other?

A friend sends an address, and you copy it into a map by hand. Our apps sit on the same phone yet barely know each other exist. Why is the user still the bridge?

· Updated · 6 min read

Two app tiles drawn as isolated islands on a light blue grid with a broken dashed line between them, and the words "Why don't our apps talk?" at the top left.

Last week I asked why a phone still has to be Android or iOS. That question is about the floor we stand on. This one is about the rooms built on top of it.

Take a small, ordinary moment. A friend sends you a restaurant address in a chat. You long-press the message, copy the text, open a maps app, paste it, fix a line break that came along for the ride, and search. Then you go back to the chat to say you're on your way.

None of that was hard. That's the point. It was so ordinary that I almost didn't notice I was doing the work of connecting two pieces of software that live a few centimetres apart on the same chip.

So the question for this post is simple: why don't our apps talk to each other?

Apps are islands

Open your phone and look at the home screen. Every icon is its own little world. Each app has its own account, its own storage, its own idea of who your contacts are, and its own copy of things you have already told some other app.

Part of this is deliberate, and for a good reason. Modern phone operating systems isolate apps from each other on purpose. Android, for example, gives each app its own user ID and runs it in its own process, so one app cannot simply read another app's files. iOS sandboxes apps in a similar way. This protects us. A flashlight app should not be able to read your messages.

But security isolation explains why apps can't reach into each other. It doesn't explain why they so rarely choose to talk, even when the user clearly wants them to.

The user as the bridge

When apps don't talk, someone still has to move the information. That someone is us.

Some everyday examples:

  • Addresses and plans. An address arrives in chat, gets copied into maps, then the arrival time gets typed back into chat by hand.
  • Orders and receipts. You buy something, and the order number lives in an email. A day later you retype it into a support form in the store's own app, or into a delivery app, or into your notes so you can find it again.
  • Events. A ticket sits in one app, the date in another, and the calendar entry is something you make yourself.
  • Photos and files. You want a document from one app inside another, so you save it to your files, find it again, and upload it.

Each step takes seconds. Together they make up a strange job description. The person holding the phone is the integration layer. We are the clipboard, the scheduler and the error correction.

The share sheet is a doorway, not a road

Phones do have a built-in way for apps to hand things over. On Android it is the sharing intent. On iOS it is the share sheet, built on the system's activity view controller. You tap Share, pick an app, and some content moves across.

It is genuinely useful, and I use it every day. But look at what it actually is. It is a one-time hand-off of a piece of content, usually started by you, usually one item at a time. The receiving app gets text, a link or a file. It does not get context. It doesn't know this address belongs to Saturday's dinner, or that the photo is a receipt for the order in your email.

And nothing stays connected afterwards. If the restaurant changes the time, the chat knows. The map and the calendar don't.

Walled gardens and attention

So why don't apps build richer connections themselves? The technical tools exist, at least partly. Android has content providers for sharing structured data between apps. Both platforms have deep links. The pieces are there.

I think the honest answer is about incentives more than engineering.

Many of the biggest apps are free and earn money from time and attention spent inside them. An app that hands you off cleanly to another app is, in business terms, an app that just lost you. So the natural move is to pull more features inside: messaging apps add payments, shopping apps add chat, social apps add maps and video. Each one tries to become the place where everything happens, rather than one good part of a connected whole.

I don't think this is anyone being evil. It is a reasonable response to how these products are paid for. But the result is that the walls around each app get thicker over time, not thinner. Your data, your contacts and your history get spread across many gardens, and each garden has a gate that opens mostly inward.

Regulators have started to notice one corner of this. The EU's Digital Markets Act includes Article 7, which requires designated gatekeepers to make the basic functions of their messaging services interoperable with other messaging providers. Whatever you think of regulation, it is telling that something as basic as two chat apps talking had to be written into law.

Two locks, one cage

Put this next to Friday's question and a pattern shows up.

The first lock is the operating system. For most people, the phone is Android or iOS, and the cold-start loop keeps new platforms out.

The second lock sits underneath it, inside the phone. Even within one operating system, the apps don't share much. Each one keeps its own slice of your life and asks you to carry the rest.

The two locks support each other. The OS layer decides how apps may communicate, and mostly allows narrow, user-triggered hand-offs. The app layer, for business reasons, has little interest in going further. So the user ends up in the middle, doing the connecting by hand, on both levels.

I find it useful to name this plainly, because each lock on its own looks reasonable. Isolation is good for security. Free apps need attention to survive. It is only when you stack them that you notice how much of our daily phone use is just moving things from one place to another.

Conclusion

Our apps are islands. Some of that is careful security design, and I wouldn't want it gone. Much of it, though, comes from incentives that reward keeping people inside one app instead of letting information flow to where it is useful. The share sheet gives us a doorway between islands, but we still do the walking.

So I will leave the question where it started, because I'd really like to hear how others see it:

Why don't our apps talk to each other?

If you have an everyday example where you are the bridge between two apps, or a reason you think things should stay this way, I'd like to read it.

References

← Back to writing