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 to build better distributed systems. We help teams solve three main pain points:

(1) Build, Test, and Debug Integrations with Ease.

Platform Notebooks are the ultimate tool for designing, testing, and sharing integrations — no coding expertise required.

(2) Debug Smarter, Not Harder.

Say goodbye to manual "steps to reproduce an issue" and endless APM data searches. Multiplayer provides you with:

  • Complete visibility into your system with Auto-Documentation
  • Complete session capture with Platform Debugger. Capture everything—frontend screens, backend traces, metrics, logs, and full request/response content and headers.

(3) Effortless Platform Design and Documentation

Capture everything—logical architecture, components, APIs, dependencies, environments, and design decision—without manual effort. Multiplayer provides a single platform for all your system design documentation assets and collaboration activities.

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?​

  • Code More, Document Less. Auto-Documentation automatically generates always-accurate system docs—architecture, APIs, dependencies, and flows—so your team stays aligned and spends less time on manual updates.

  • Debug Smarter, Not Harder. The Platform Debugger captures every detail—frontend screens, backend traces, logs, and metrics—so you can reproduce and resolve bugs in record time, keeping your customers happy.

  • Integrate in Minutes, Not Days. Platform Notebooks simplify RESTful API integrations with no-code/low-code tools, accelerating development and collaboration with customers and partners.

  • 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.

What if I don’t use OpenTelemetry?​

No problem! While OpenTelemetry is a powerful tool for gathering telemetry data and powers our System Dashboard and Platform Debugger, it’s not a requirement to use Multiplayer. You can still manually add and manage your system’s components, APIs, and dependencies through our intuitive interface.

Here’s how you can get started without OpenTelemetry:

  1. Use Platform Notebooks to build, test, and share API integrations

  2. Import and/or Manually Document your System Architecture Diagrams: Use Platforms to visualize your system architecture. You can manually add components, APIs, and dependencies or import them via CSV or image files. You'll have access to the full suite of version control and system design collaboration functionalities.

  3. Collaborate on Your System Design: Request design reviews, iterate on architecture changes, and align stakeholders across your organization. Whether you’re planning a major architecture refactoring or just adding a new feature, your team can contribute and stay in sync in one shared space.

  4. Create a Single Source of Truth for all your System Information: Leverage Notebooks to document decisions, brainstorm ideas, and store architecture discussions in a structured and searchable format.

    Use Sketches to create or refine architecture sketches collaboratively.

    Organize your Environments to track different deployment configurations.

    Link your Repositories to associate your GitHub, GitLab and Bitbucket reposts to your platform information.

If you’re considering OpenTelemetry, we encourage you to explore its benefits, especially for larger, more dynamic systems. It simplifies ongoing updates to your system architecture documentation and enhances observability across your platform.

Reach out to our team if you’d like guidance on getting started.

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
  • Teams
  • 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 by following these getting started steps.

For 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 Automated, 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 ato whiteboard your ideas.
  • Notebooks to record your architectural decision records and design, test and share API integrations.

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. Use the System Dashboard and Platform Architecture Diagrams for that.

  • Effortlessly identify bugs and issue root cauese(s) with deep session replays that capture all the session data from the frontend and backend. Use the Platform Debugger for that.

  • Design, test and share API Integrations with ease. Use the Platform Notebooks for that.

  • 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. Use the System Design Reviews for that.

  • 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. Use all the features in the Single Source of Truth toolset for that.

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 Platform Views, you can create filtered views of your architecture diagram, so a complex platform can be simplified by focusing on key components for their function.

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

On our roadmap:

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 Auto-Documentation functionality to run in the background, automatically creating and updating the System Dashboard and your Platform Diagrams 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.

You can use Multiplayer with or without integrating with OpenTelementry.

We leverage the OpenTelemetry integration for only two features:

  • Complete visibility into your system with Auto-Documentation which can auto-detect:

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

  • Complete session capture with Platform Debugger. Capture everything—frontend screens, backend traces, metrics, logs, and full request/response content and headers.

Setting up OpenTelemetry 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.

OpenTelemetry supports various languages including C++, .NET, Erlang/Elixir, Go, Java, JavaScript/TypeScript, PHP, Python, Ruby, Rust, and Swift.

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 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 when creating your Platform Architecture Diagram.

You can import your system architecture information as a

  • CSV file
  • Diagram mages (.png, .jpg, .jpeg)

We will extrapolate the data and present you with a list of components to review.

You can also enable Auto-Documentation which will auto-detect all the components and dependencies in your system and auto-generate the Platform Diagram for you.

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 a CSV file with your components and dependecies or images of your diagrams.

For brownfield projects, your existing diagram images might not capture the full complexity of your system or they might be outdated. Likewise, listing all the components and dependencies in a CSV file might require too much tim.

That’s why, we recommend enabling Auto-Documentation which will auto-detect all your components and dependecies and auto-generate the diagram for you.

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 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.

-Platform Architecture Diagrams and the System Dashboard automatically provide real-time information into your system architecture and all its components. From the logical architecture, down to all the components, dependencies, APIs, etc.

  • The Platform Debugger allows your team to record and share deep session replays that include relevant data from frontend screens to distributed traces, metrics, and logs from your backend platform. All the information and steps to reproduce a bug are captured in a single recorded session, making it easy to share issues within the team and saving huge amounts of time for everyone involved.

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 Auto-Documentation and Platform Debugger, Multiplayer offers a comprehensive solution for debugging issues, including outages and performance incidents.