Skip to main content

Multiplayer FAQ

đź“Ś If you have any questions shoot us an email or join us on Discord! đź’ś

What is Multiplayer?​

Multiplayer is a collaborative platform for system design, auto-documentation and debugging. We aim to improve how engineering teams design, develop, and manage distributed systems.

Aside from providing a full system design and architecture visualization suite of features, we also leverage OpenTelemetry for two critical use cases:

  • System Auto-Documentation: Discover, track and auto-document your system, including logical architecture, system components (apps, SaaS services, etc.), dependencies, APIs and data flows. We eliminate manual system documentation, which is time consuming, error-prone, and gets out-of-sync quickly as a system changes.

  • Platform Debugger: Find and fix issues in your distributed system without having to manually dig through APM logs, metrics and traces. With a click you can record and share deep session replays that include relevant data from frontend screens to distributed traces metrics and logs from your backend platform.

Get up and running with Multiplayer in under two minutes by following these getting started steps.

What are the key features?​

What are the benefits of Multiplayer?​

  • Automation of Manual Tasks. No need to manually create or update diagrams or worry about documentation errors—Multiplayer discovers, tracks and auto-documents your system architecture, notifying you in real-time of documentation drift. You’ll never have a disconnect between your system architecture and your documentation again.
  • Easier Collaboration. Collaboratively share, review, and adjust system design decisions, before jumping into code. Ensure all stakeholders are aligned at all times and have access to the latest information they need, broken down by view. Identify potential breaking changes before it’s too late so you can focus on building, not backtracking.
  • Single, Secure Knowledge Base. Access accurate, realtime information about your entire system, in a single, secure location. From high-level architecture to its components, APIs, dependencies, and decision records - your actual running system becomes your source of truth. No more searching in multiple places for system documentation or struggling because a team member walked out with knowledge in their head.

Why build Multiplayer now?​

Our co-founder, Thomas Johnson, came up with the idea for Multiplayer nearly 15 years ago but the market wasn't ready. Fast forward to today’s complex technical landscape and Multiplayer has become an imperative for teams that work on distributed software:

  • Increased Technological Complexity. More and more companies are migrating from centralized systems to distributed application environments to gain significant advantages in performance, scalability, and fault tolerance. The proliferation of microservices, APIs, SaaS products and cloud-native technologies have further increased complexity.
  • Increased Documentation Requirements. The adoption of Agile methodologies and modern design practices like Continuous and Evolutionary Architecture have significantly increased the rate of change within software systems. Teams have to manually create and update their documentation constantly to reflect changes in infrastructure, new technologies, evolving business requirements, and more.
  • Changing Team Dynamics. System design is a collaborative activity that requires the alignment of multiple stakeholders, who may be completely remote from one another. This is especially true with the globalization of the workforce and the increase in remote / hybrid work solutions. This complexity is compounded by the tech industry's high turnover rate (with developers often changing roles every 1 to 2 years) and company layoffs.

These factors underscore the need for tooling that is purpose-built for understanding, designing, and managing modern software systems.

How much does Multiplayer cost?​

Multiplayer offers three flexible plans that can scale with your team’s requirements:

  • Free Forever
  • Pro
  • Enterprise

Check our billing FAQ for more details.

How does one deploy Multiplayer?​

Multiplayer is a SaaS product with monthly and annual subscriptions.

You can get up and running with Multiplayer in under two minutes by following these getting started steps.

For System Auto-Documentation and Platform Debugger we use OpenTelemetry (OTel) to collect telemetry data. Instrumenting OTel in your application takes less than five minutes and is similar to setups for APM providers like Datadog or New Relic.

We plan to offer a self-hosted option for enterprises in the future. Be sure to check out our roadmap.

Who is the team building Multiplayer?​

Multiplayer was founded by Steph Johnson, CEO, and Thomas Johnson, CTO, who have extensive backgrounds in developer tools and software development.

Steph brings 25+ years of Go-To-Market experience from companies like DigitalOcean, HP and MongoDB, specializing in developer tools and brand building.

Thomas has 25+ years of experience as a founder and backend developer at companies like Citrix. His vision for Multiplayer is to create a collaborative tool that provides easier ways to design, develop and manage distributed systems.

Our fully remote team includes engineers from the US, Romania, Kyrgyzstan, Armenia, and Ukraine. We pride ourselves on fostering a diverse and inclusive environment, with women making up 50% of our engineering team.

How is Multiplayer different?​

Some key differentiators include:

How does Multiplayer compare to and/or integrate with Diagramming Tools?​

Diagramming tools visualize specific portions, structures, or behaviors of a software system. They provide static abstractions for specific audiences, focusing on visual representation while simplifying or excluding component details, APIs, dependencies, integrations, repositories, and environments.

Examples include: Lucidchart, Visio, Miro, FigJam, etc.

In the past, when software systems were smaller and simpler, a single static diagram could capture a lot of a system’s information and it would still be current for a period of time after it was created.

Today, with such a high number of SaaS products, microservices and API’s plus the amount of legacy technology that many companies still have, the complexity of software systems has increased exponentially. General purpose diagramming tools are inadequate for capturing and understanding their full scope.

These are their limitations of diagramming tools compared to Multiplayer:

  • Lack of Real-Time Updates: Static diagrams can't automatically reflect dynamic systems.
  • Clunky User Interface: Updating diagrams can be cumbersome, with significant time spent on formatting and arranging boxes and arrows.
  • Version Control Issues: Maintaining updated versions across teams is challenging.
  • Limited Collaboration Capabilities: Real-time collaboration and feedback are often not well-supported.
  • Lack of Key System Information: Diagrams rarely include information about requirements, trade offs, design decisions, etc. Design documentation is often scattered across various platforms like Confluence, Notion, GDocs, etc., lacking integration.
  • Incapable of Managing Cloud Resources: Diagrams cannot control or generate infrastructure code (e.g., CloudFormation, Terraform).

Multiplayer addresses these issues by providing real-time system architecture information, comprehensive functionality for system design, and a 360° view of your system information.

Diagramming tools do work well for whiteboarding and quick idea sharing, and this is why Multiplayer offers an integrated solution called "Sketches" using Excalidraw for an elegant and seamless way to depict things visually.

How does Multiplayer compare to and/or integrate with Enterprise Architecture (EA) tools?​

Enterprise Architecture (EA) tools help organizations analyze, design, plan, and implement strategies for digital transformation, IT growth, and business outcomes. They focus on tracking enterprise software and SaaS assets for functions like finance, HR, and IT.

Examples include: Orbus, MEGA, LeanIX, etc.

Multiplayer is complementary to Enterprise Architecture (EA) solutions and we have planned integrations with these tools on our road map.

We bring all the elements of backend software development together into one platform so teams can not only visualize their system but also work on it collaboratively.

Our focus on engineering teams ensures deeper and more accurate information about purchased or internally-developed software for EA tools.

How does Multiplayer compare to and/or integrate with existing documentation solutions?​

Documentation solutions are tools and platforms that capture and communicate the knowledge and details of software systems, processes, and practices within an organization.

Examples include: Confluence, Google Docs, Notion, etc.

Multiplayer is complementary to these tools and plans to build integrations with many documentation solutions, allowing you to pull all the necessary information into one place without duplicating resources.

We currently support:

  • Integrations with GitHub, GitLab or BitBucket so that you can open, view and (coming soon) modify source code within the context of your platform design.
  • Sketches and Notebooks to whiteboard your ideas and record your architectural decision records.

On our roadmap:

  • Two-way integrations with tools like Confluence, Google Docs, Notion, etc.
  • Embeddable interactive platform diagrams, API changes, and platform sessions inside Jira, Linear, Confluence, Notion and Google Docs.
  • Create/update issues in tools like Jira, Linear, and Trello.

ℹ️ If you’re interested in these features send us a note - this will help us prioritize what you need the most!

Does Multiplayer integrate with standard tools such as GitHub?​

Multiplayer integrates with GitHub, GitLab and BitBucket so that you can open, view and (coming soon) modify source code within the context of your platform design - making it possible to connect the high-level logical system architectures to the low-level code (e.g., where an app or service is implemented) and APIs.

This makes it easy to answer questions like:

“what is your software architecture?”

“where is the implementation of X microservice?”

“what is the flow/interaction between components when X API is called?”

“what will break if I change X API method or schema?”

On our roadmap:

  • Two-way integrations with tools like Confluence, Google Docs, Notion, etc.
  • Embeddable interactive platform diagrams, API changes, and platform sessions inside Jira, Linear, Confluence, Notion and Google Docs.
  • Create/update issues in tools like Jira, Linear, and Trello.

ℹ️ If you’re interested in these features send us a note - this will help us prioritize what you need the most!

Is Multiplayer a daily use tool?​

Multiplayer plays an active role in the product development process for teams working on distributed systems. Here’s how you can leverage it daily:

  • Make informed decisions based on accurate and real-time data. Quickly confirm your system architecture, dependencies, APIs, current product requirements, and refer back to past architectural decisions before coding.
  • Align on the consequences of a change with all the relevant stakeholders. Eliminate surprises and bottlenecks by conducting sanity checks with relevant stakeholders before developing a new feature, refactoring a portion of the system, or making any other change.
  • Save time by auto-documenting all your system changes. Multiplayer automatically discovers, tracks, and documents your system architecture, eliminating time-consuming, error-prone, and manual diagramming and API documentation processes.
  • Easily onboard (or offboard) new team members or cross-functional teams. New hires have an immediate and accurate resource to get up to speed on platform architecture and previous design decisions, while also ensuring that knowledge and company IP is protected during employee/team turnover.

Check out this article for more suggestions on how to integrate system design and architecture documentation into the Agile lifecycle.

Can I use Multiplayer during onboarding?​

Yes. Multiplayer streamlines onboarding by providing automatically generated and always up-to-date system architecture documentation. New hires can review the documentation at their own pace, minimizing impact on the rest of the team.

With features like “Views”, you can create filtered perspectives of your system, so a complex platform can be simplified by focusing on important parts (e.g., an “auth” view of a system may include just the components involved in authentication or authorization).

Check this article for more about developer onboarding documentation must-haves.

On our roadmap:

  • A “group” feature for zooming in and out on different levels of detail.

ℹ️ If you’re interested in this feature send us a note - this will help us prioritize what you need the most!

How does Multiplayer discover my system architecture?​

Multiplayer uses OpenTelemetry, a vendor- and tool-agnostic open source observability framework and toolkit, to capture distributed traces, logs, and metrics from your system. This is similar to how any APM provider works. We use this data to help us identify your system’s components, environments, dependencies, and APIs.

You can enable the System Auto-Documentation functionality to run in the background, automatically creating and updating documentation as it detects changes.

Alternatively, you can review and approve each detected change before it is merged into your published documentation.

Multiplayer does not analyze source code to discover architecture and system design.

Can Multiplayer be integrated with any platform and/or development environment?​

Yes, Multiplayer is platform agnostic.

Setting up Multiplayer to discover and track the components, environments, dependencies, and APIs in your system architecture is similar to setting up an APM provider like Datadog or New Relic. Simply add a few lines of code to your clients and microservices.

We leverage OpenTelemetry for our system auto-documentation functionality, which supports various languages including C++, .NET, Erlang/Elixir, Go, Java, JavaScript/TypeScript, PHP, Python, Ruby, Rust, and Swift.

Our service can discover any:

  • Platform component (e.g. web or mobile apps)
  • System architecture style (e.g. microservices)
  • Database
  • SaaS product
  • Cloud provider (e.g. AWS, GCP, Azure)

Does Multiplayer work with both on-prem and cloud-hosted software systems?​

Yes, Multiplayer supports any environment type: on-prem, cloud or hybrid.

Additionally, we accommodate any type of distributed system architecture, from simple client/server systems to complex, multi-cloud, microservices architectures with tens of thousands of components.

Does Multiplayer support both monorepo and multi-repo deployments?​

Yes, Multiplayer supports both monorepo and multi-repo deployments.

You can connect your Git repositories following these steps.

How responsive is Multiplayer in detecting change in live environments?​

Multiplayer is highly responsive, detecting real-time drift between your documented system architecture and your actual software system. Changes to any of your system’s components, environments, dependencies, and APIs will be immediately detected and your system will auto-document itself.

How does Multiplayer ensure data protection?​

Security is one of our priorities. Specifically for the system auto-documentation feature, we ensure:

  • Data encryption at rest and in transit in our platform
  • Masking of fields
  • Generation of “schemas” from data, rather than storing the data itself during auto-documentation.

On our roadmap, we plan to introduce Enterprise SSO/SAML 2.0, advanced security integrations, self-hosting options, and more.

ℹ️ If you’re interested in these features send us a note - this will help us prioritize what you need the most!

I already have diagrams of my system architecture, do I need to start from scratch?​

No, you don’t have to start from scratch.

You can use the Multiplayer AI Assist feature to upload all your existing diagram images or freehand sketches. We process the image files (.png or .jpg), extract the system components, and allow you to edit and select those to add to your platform.

You can then enable the System Auto-Documentation functionality to run in the background and automatically update diagrams and documentation as it detects changes in your system architecture.

Multiplayer aims to enhance and complement any existing documentation and workflows, while removing the overhead from having to perform manual tasks or wasting time searching for information.

What is OpenTelemetry and how to get started?​

OpenTelemetry (OTel) is an observability framework and toolkit designed to create and manage telemetry data such as traces, metrics, and logs. It’s a vendor- and tool-agnostic, open source Cloud Native Computing Foundation (CNCF) project, born out of the need to standardize how to instrument code and send telemetry data to an observability backend.

Instrumenting OTel in your application requires five minutes. Here are the steps:

  • Import the OpenTelemetry API and SDK
  • Configure the OpenTelemetry API
  • Configure the OpenTelemetry SDK
  • Create Telemetry Data

OTel provides language specific “getting started” guides for C++, .NET, Erlang/Elixir, Go, Java, JavaScript / Typescript, PHP, Python, Ruby, Rust, Swift, etc.

Can you auto-document both greenfield and brownfield projects?​

Yes, we can do both.

For greenfield projects, you can manually add new components as you design and build your platform. You can also import any existing early sketches or draft diagram images.

For brownfield projects, your existing diagram images might not capture the full complexity of your system. That’s why, after importing your images, enable our System Auto-Documentation functionality to automatically discover and track all the components, environments, dependencies, and APIs in your system architecture.

By leaving this functionality enabled, it will run in the background and it will detect any drift in your system architecture.

Is there a limit to how complex a system can be?​

Multiplayer handles both simple and highly complex architectures with ease.

Our customers' systems range from basic client/server setups to intricate multi-cloud environments with thousands of microservices and SaaS dependencies.

For large projects, how scalable is Multiplayer’s platform?​

Multiplayer is designed to scale with organizations of any size and we can build custom support packages for our larger customers.

Can Multiplayer import Terraform config files to automatically create architecture diagrams?​

No, we don’t currently read Terraform files to reverse engineer system architectures.

Instead, we use OpenTelemetry to automatically discover, track, and detect drift in your system architecture, dependencies and APIs by directly connecting the components in your infrastructure.

We are developing a feature to connect system architecture with deployments and environments using Terraform, linking the logical architecture to the infrastructure as code (IaC).

ℹ️ If you’re interested in this feature send us a note - this will help us prioritize what you need the most!

What access does Multiplayer require to auto-document your system?​

You need Workspace Admin access to any project where you would like to enable the System Auto-Documentation functionality.

Additionally, you’ll need access to your platform’s source code to instrument OpenTelemetry in your application.

This set up takes less than five minutes, a few lines of code, and is similar to setups for APM providers like Datadog or New Relic.

How are output formats available?​

Multiplayer stores data within our SaaS platform and can generate reports in CSV and JSON formats.

On the roadmap:

  • Self-hosted option for enterprises
  • Embeddable interactive platform diagrams, API changes, and platform debugging sessions inside Jira, Linear, Confluence, Notion and Google Docs.

ℹ️ If you’re interested in these features send us a note - this will help us prioritize what you need the most!

Does Multiplayer also include database mapping?​

No, Multiplayer does not include database mapping at this time.

We connect to source repositories and allow users to include source code in system design reviews using our branching feature.

This enables users to include anything, including SQL scripts, in feature development and easily show diffs and changes when getting approval for new designs.

ℹ️ If you’re interested in this feature send us a note - this will help us prioritize what you need the most!

How does Multiplayer improve debugging compared to traditional tools?​

Organizations, especially those with legacy systems and technical debt, often don’t have visibility into their systems or accurate documentation. It's difficult to debug without a comprehensive view of the entire software system, including all components, dependencies, and integrations.

  • Multiplayer Architecture Visualizations and Auto-Documentation uniquely allows you to visualize your system architecture in real-time and auto-document it, enabling teams to find and fix bugs using accurate and complete data.

  • Platform Debugger: Allows you to record and share deep session replays that include relevant data from frontend screens to distributed traces metrics and logs from your backend platform. Teams won’t need to search for the needle in the haystack in their APM data or manually document the steps to reproduce an issue. It will all be captured and presented in a recorded session, making it easy for QA or DevOps to share issues with developers and saving huge amounts of time for everyone on the team.

On our roadmap:

  • Platform Debugger integrations: Easily add links to debugger sessions in tools like Jira, Linear, Confluence, and Trello.
  • Flows: Visualize sequence diagrams with detailed dependency information at the component and API level for easy understanding of low-level relationships.

ℹ️ If you’re interested in these features send us a note - this will help us prioritize what you need the most!

During application outage/performance incidents can we leverage Multiplayer for troubleshooting or document crisis management?​

Yes, with our System Auto-Documentation feature and Platform Debugger, Multiplayer offers a comprehensive solution for debugging issues, including outages and performance incidents.