The rise of multiplayer SaaS

The last decade has seen SaaS become a crown jewel for investors. While its market in 2013 was worth an estimated $30.4B, it’s now close to $146.6 billion and is expected to hit $168.6B by 2025, despite the current macroeconomic environment. Recurring revenue is a big reason why VCs view this business model as attractive. In contrast to ad revenue, which vulnerabilities we’ve seen in times like these, subscription models can unlock an additional opportunity for sustainable high growth. That opportunity is multiplayer.

Figma is currently one of the most notable examples of the power that lies behind a multiplayer SaaS company. Leaving aside the controversy and backlash it has created among communities of designers, Adobe’s acquisition of Figma earlier this year was one for the record books, coming in as the second-largest acquisition of a private tech startup (just $1.8B behind Facebook’s WhatsApp).

Figma's collaborative nature drove much of its growth and success—the more folks use it, the more valuable it becomes. But getting that right is not always easy.

In this article, we’ll walk you through the challenges that SaaS customers used to experience in the early days, how far products have come, and what to pay attention to when baking multiplayer into yours.

A brief history of SaaS

To understand why we’re seeing collaboration become such a big topic of discussion, we have to understand how things used to work.

What’s the first name that pops into your head when you hear B2B SaaS? For many, it’s Salesforce. While it’s true that the original SaaS behemoth was at the forefront of cloud computing (and implicitly SaaS), earlier versions of B2B existed. Albeit somewhat different.

The sheer amount of cutting-edge B2B tools that have sprung up in recent years makes it difficult to remember how slow, painful, and complicated these used to be. Most of them came on CD-ROMs or floppy disks and required thorough customization on top of an orchestrated rollout. Since B2B tools didn’t yet exist in the cloud, it also meant that they had to be installed on-premise, which soon proved to be inefficient. Scaling became challenging, with overwhelmed IT teams scrambling to fix issues and updates.

The dot-com bubble and rise of cloud computing quite literally showed how “software is eating the world.” Allowing companies to plug and play the software they needed to run their businesses lifted so many barriers to growth. It was no longer necessary to hire specialized teams to maintain and install software. Scalability was finally achievable, and the potential for exponential growth was in sight.

Concur’s story is an excellent testament to this. The company started by selling floppy disks and CD-ROMs of expense software in computer software stores. Witnessing the rise in software consumerization, Concur decided to switch models and sell directly to enterprises. One economic downturn later, it pivoted to pure SaaS and eventually built what we now call a category-defining company, selling to SAP for $8.3B in 2014.

Collaboration headaches

Despite remarkable advancements, collaboration was still a headache. The more people used an application, the harder it became to track changes and updates. Emailing versions of files back and forth became the norm and led to inevitably making edits to a slightly out-of-date document, thus losing valuable work.

Naming a Word/Excel document or Photoshop file after the 1,000th edit isn’t just a meme but a classic example of that time. You’re likely guilty of appending version names with “final,”“finalfinal” or “finafinal(1),” too.

Keeping shared folders organized and in sync was painfully difficult. Having a file naming convention and a folder structure that staff had to remember didn’t help either.

The emergence of multiplayer software

Yes, the emergence of cloud computing changed a lot of things for the better. We’ve gone from servers and file-based sharing (requiring moving, organizing, and sending files) to the cloud, where the app and the data are one and the same. It’s one of the reasons Figma leap-frogged incumbents like Sketch and Adobe. But it’s not the whole story.

How we work with many apps is still inefficient — copying and pasting links or sending screenshots using Slack, or MS Teams removes much of the context that’s needed in collaboration and is what’s driving the need for multiplayer. It’s how Figma won.

On top of making the entire design process more accessible and more intuitive, it brought everything and everyone together. Not just designers but everyone involved in the design process. Figma removed the friction of having a non-designer try to open a .psd file only to realize they don’t have Photoshop installed. This used to be solved through screenshots, but screenshots get lost, and so does the feedback you send fragmented into hundreds of different messages across tens of different channels.

In hindsight, its success seems almost too obvious. Although multiplayer wasn’t as hot of a topic as it is currently, a few particular applications were paving the way. Most notably, Google taking on Microsoft Office through its productivity suite and its army of Anonymous Armadillos and Buffalos.

Microsoft Word became Google Docs; Excel turned into Google Sheets, and PowerPoint into Google Slides. Players in the startup space started to take notice of how incumbents were struggling to keep pace. It’s when we started to see Figma begin to gain traction.

We’ve since witnessed even more progress towards multiplayer: Pitch launched as an alternative to Google Slides, offering further customization and collaboration. Another area of heavy multiplayer use is visual collaboration, like whiteboard tools. Figma, among others like Miro and Mural, took note of this and launched FigJam in 2021 as part of their ecosystem.

This multiplayer trend is also seeing increasing popularity in the developer space. GitHub’s Codespaces offers developers a standardized environment for collaboration, removing the back and forth of ensuring that configurations are the same across an entire team. Replit goes a step forward. Its Multiplayer uses a Google Docs-like interface to allow collaborators to see each other’s cursors and where changes are made. A chatbox can be used to synchronously work on debugging.

The pandemic and remote/hybrid revolution pushed many tech companies to look at how their products can be used when teams aren’t physically close to each other. If the goal is to maximize how much time customers spend WITH your product, having them debrief their work on Zoom calls isn’t exactly how you get there. Seed-stage VC firm Seedcamp highlights some of the verticals that are embracing collaboration through multiplayer features.

Benefits of multiplayer

Just taking a brief look at a market map like the one above makes you realize the vast amounts of apps tech employees use on a daily basis. Think about it — you log in in the morning. Check your email app and then Slack. Say you’re a PM currently working on pushing out dark mode for your mobile app. You check the latest documentation on Notion, then move to Asana or Linear to see what tasks are due today. Having specialized apps for different purposes is great and is part of the excitement of being in tech, but it also means there is now more context-switching than ever before.

Avoiding the back and forth between these apps and email, Slack, Zoom, and the likes is what makes collaborative features great. You get to stay in context and do the deep work. It’s because everyone in that Figma file for your dark mode rebrand is there with the same purpose — to design the new dark mode experience. Alternatively, going on Slack to get feedback on some recent screenshots you’ve sent will inevitably result in other distractions like filling out your weekly stand-up and five other notifications in different channels. There’s a time and place for each task, but multiplayer allows us to focus entirely on one at a time.

Looking through the business lens, multiplayer makes a growth marketer’s heart sing. Collaboration is the perfect complement to product-led growth, which is a classic “pull” tactic for most SaaS companies. Making it easier to invite others to collaborate doesn’t just make the experience better for the user; it also helps you grow and results in lower churn.

Once again, it’s part of why Figma did so well. While they did initially focus on making the single-player experience great, it’s the fact that you invited your entire team (and beyond that) to use it that led to the widespread adoption.

Getting the experience right

By this point, you might ask yourself — multiplayer sounds great. Why don’t all apps have it? Some simply don’t need it. For most teams, though, to put it lightly, building a multiplayer product is tough. From almost every angle.

It's technically difficult

Designing the collaborative features you’re envisioning and thinking through the flows a user might go through can be fun. But there are so many of these flows.

• Building features like a chatbox or annotations is often not the hardest part (although still complicated AND time intensive) — debugging is. With the number of permutations that exist (and that increase with the number of people using the product simultaneously), it quickly becomes very tricky to recreate everyone’s state and figure out where a bug is.
• Additional small details you don’t think about at the start are things like the ability to format and edit (always a must!) text or embed images and GIFs in comments or chat. User identity can also become complex very quickly — do people have their own profiles? What does each profile include? An avatar and links to their social handles? Maybe a short bio?
• Permissioning can get cumbersome. Which users can access which pages? Can all users see all comments? If you give folks from outside access to public pages, you should consider giving them the ability to add comments and contribute, which raises the issue of moderation.

People don’t always act as expected

While you use shortcuts to navigate around a product, someone else on your team might not even know about that option and simply uses the navigation menu. When you’re adding multiplayer to your product, you have to take into account contrasts like these, understand how different people can use the same product in various ways, and accommodate for the most common cases. One way this can be done is through search intent. More specifically, identifying and reviewing what people search for when using your product and how easily they get (or don’t!) there to try and figure out user intent.

Beware data-syncing woes

With debugging being so tricky, the opportunity for data loss is high. If an error happens when syncing, it’s easy to overwrite or drop people’s contributions. Nailing down the sync app states between users so that they’re able to make data edits synchronously is crucial.

Where there’s a challenging problem, there’s often an opportunity for new companies to emerge and solve it. Dedicated services like Cord, Liveblocks, and Snippyly are doing that. Generally speaking, they work through SDKs / APIs and walk you through all the pre-built UI components you’ll need to add to your existing app.

When it comes to the backend, frameworks like Microsoft’s Fluid can help handle the synchronization of shared states between users and minimize the risk of data loss. Tools like Pusher and Ably can also help ensure that the real-time user experience works smoothly.

Finally, if you do decide to embark on the journey of adding multiplayer to your product in-house, here are a few core elements that make for a good experience and shouldn’t be overlooked:

• Comments - including threading and @mentions; they should be contextual
• Annotations - so folks know exactly what you’re referring to
• Live presence - usually through live cursor movements and being able to see who’s currently accessing the same page as you
• Integrations - make sure your product actually plays well with others
• Notifications - knowing when someone made edits or left comments is important

Additionally, these could add a fun touch but aren’t always essential:

• Audio huddles - for when async comments don’t quite cut it
• Offline support - making sure that updates made when you’re offline sync as soon as you go back online
• Chatbox - a nice edition to complement comments

Hopefully, after reading about what goes into creating a multiplayer experience and watching Figma rise to the top, you have a better idea of whether it’s time to invest time and resources into bringing it to your product too.

At the risk of sounding cliché, you’ve got to move fast, (moderately) break things, and learn from Sketch: they spent months researching the right approach, looping in community members, and thoroughly testing it, but ultimately were too slow to add collaborative features, with much of the market shifting to Figma.