Thread by @amaldorai

I'm not surprised that Adobe is acquiring Figma for $20B, nor that Wall Street doesn't understand it and $ADBE stock is down more than $20B today. It's a smart move for Adobe because it's nearly impossible to make legacy software applications multi-user collaborative. Thread: 🧵

I know this because I founded a startup, LiveLoop, to make MS Office real-time collaborative. Microsoft acquired us in 2015 and has invested heavily in making Office real-time collaborative, and Office collaboration is now much better than in 2016. But it's still not Google Apps.

There are two major barriers to making a legacy application into a multiplayer application: the file format and its ecosystem, legacy clients and backwards compatibility, and the pure technical challenge of multiplayer. Let's start with the file format:

Legacy applications speak "file." Photoshop users have thousands of .psd files in their archives, they share .psd files with Dropbox, they send .psd files as email attachments, and they have .psd files with names like "Billboard_Final_v26_REALLYFINAL_v6.psd."

The file-based semantics enable users to work with their data offline, and maintain custody of their own data (You can't lose access to your PowerPoint files on your desktop, but you can lose access to your Google account). But the file has two major limitations:

First is that a legacy file format like PSD has a multi-thousand page specification, with none of it designed around multi-user applications. You can't replace the file format outright, because then older versions of Photoshop wouldn't be able to access the new file format.

So changing the file format requires shoehorning in the functionality required for real-time collaboration, in a way that older clients ignore. This is a solvable, but what's not solvable is that the entire concept of a file is incompatible with multi-user applications:

A file only needs to change when a user opens it, but a collaborative multi-user application has to be editable at any time by any user, so it resides on a server and is accessed over the network. So any file that you store outside of the system becomes immediately obsolete.

Multiplayer applications like Google Apps and Figma avoid this by entirely rejecting the concept of the file . You can't download a Google Doc - you can only download a snapshot of it as a PDF. You can't "edit locally" in Google Docs.

Yes, this means that multiplayer applications don't work offline. ("Merging" a local copy with an online copy is too complex for most users.) Existing applications see this as a dealbreaker because it would be a takeback of functionality that users are accustomed to.

But Google Apps, Figma, etc. have shown that while users may not allow Adobe to take away offline editing, they will use a competitor that doesn't offer it. As connectivity gets more ubiquitous and collaboration becomes more important, offline support is a relic of the past.

Users of file-based apps also often have workflows that are completely based around the file. Salespeople, for example, build presentations in PowerPoint and then share and present them with third-party tools like ClearSlide and Seismic which understand the .PPTX file format.

Instead of a file format, a multiplayer application like Figma enables third-party workflows with a developer API, and users grant permissions to third parties, which then read or modify the document directly on Figma's servers.

Building a developer API is technically hard (figma.com/blog/how-we-bu…) and building developer trust program is even harder. But legacy apps ask developers to migrate to APIs right after they've destroyed their file-based business models, when trust is low.

Now let's talk backwards compatibility. Legacy desktop applications were, for decades, sold as "pay once, run forever." You bought a version of Photoshop and didn't need to upgrade. This meant that the world was running 5+ different versions of Photoshop.

Backwards compatibility became a hugely important problem for packaged software companies to solve. If Photoshop CS5 created files that people using CS4 couldn't use, users would be very reluctant to upgrade to CS5. It would break the upgrade-based business model.

If you add something like high-depth color to Photoshop, it's easy to make that backwards compatible -- just show the file in standard color on older clients. But multiplayer collaboration is too big of a change to be delivered in a backwards-compatible way.

To avoid having to support multiplayer collaboration between two significantly different versions of the software, it's essential to deliver multiplayer apps over the Web or in a desktop container, where everyone is running the same code.

Photoshop, Office, etc. aren't built to be delivered over the Web. They're multi-gigabyte applications with no clean separation between frontend and backend. Applications like Figma are architected to keep as much on the backend as possible to minimize the size of the Web app.

Finally, technical debt. It's tremendously hard to add multiplayer to an app that wasn't designed with it in mind. Instead of trying to add wheels to a boat to make it drive on land, you'd be better off melting it down and building a car.

Specifically, in an application that has 100 types of document operation (add text, change color, bring to front, add comment, change transparency, etc.), there are 100*100=10,000 ways that those can happen simultaneously from two different users.

A legacy app must define and implement those 10,000 cases to ensure the behavior tracks user expectations. For example, if I cut and paste a title to Page 2 while you're editing its capitalization, we'd both expect it to remain in its new location with its new capitalization.

Legacy apps, which were sold for decades through version upgrades, packed in as many features as possible, creating a vast number of possible interactions to define and implement (what if I change the page numbering while you change the paragraph spacing?)

Multiplayer apps start with a smaller feature set, and implement features as compositions of existing features when possible. When new features are added, the budget for them includes the additional work to make them work collaboratively with the existing feature set.

In short, Adobe would have never caught up to Figma. It's genuinely easier and cheaper for them to use Figma's architecture to rebuild all of their existing applications than to try to make any of their existing apps as delightfully multiplayer as Figma.

Multiplayer collaboration is the future of all applications, and Figma is by far the richest multiplayer collaborative app. This will go down as one of the smartest software acquisitions of all time, and if there are regrets they will be only Microsoft's, for not offering more.