Skip to main content

Use case examples

Multiplayer records what happens across your entire stack, end-to-end, and ties it all together in a single, shared session replay.

Each session captures what users saw, what the system did, and how the data moved through your services (even within your middleware and internal service calls). This gives every team the same source of truth when diagnosing, debugging, or explaining a technical issue.

Multiplayer integrates with your existing tools. You can keep using your current helpdesk, observability, and ticketing systems (e.g. Zendesk, Intercom, Jira, etc.). Multiplayer simply adds full-stack context behind every issue.

Example: how Technical Support teams work with Multiplayer​

Flowchart of support workflow

(1) End-user encounters a problem A user experiences a bug or unexpected behaviour in your application.
They report it to the Technical Support team using the Multiplayer in-app widget or browser extension.

(2) End-user records a full-stack session When opening the Multiplayer in-app widget or browser extension, the end-user can choose between two recording modes:

  • On-demand recording: Manually start and stop a session to capture exactly what matters.
  • Continuous recording: Keep a rolling record of recent activity. Multiplayer automatically saves sessions that contain frontend or backend errors and exceptions, or the user can manually save one at any time.

ℹ️ In many cases, a full-stack session recording is created during the second or third interaction on a support case. This happens because:

  • It’s not always clear right away how complex or technical an issue is.
  • Large organizations have multiple channels for reporting problems (tickets, email, chat, social media, etc.), and users may not know the best option at first.

Whenever Technical Support realizes that more context is needed (or that escalation to Engineering is likely) the best practice is to ask the end-user to record a replay.

(3) Technical Support reviews the recording A complete session replay often provides all the information needed to resolve an issue directly.
The Support team can review what the user saw, what the system did, and identify the cause without escalation.

✅ Ticket resolved — Support and users are happy.

(4) Technical Support shares the recording with Engineering In the cases of:

  • Bugs
  • Unexpected behaviours
  • Inefficient or undesirable system responses

And escalation to Engineering is needed, and the support agent adds the user’s Multiplayer session recording link directly into the ticketing system (e.g. Zendesk, Intercom, Jira) or shares it via Slack or Teams.

ℹ️ Before sharing, the agent can annotate the replay, highlight suspicious behaviour, or add comments to specific data points (APIs, spans, traces).
All of this context remains in a single link, attached to the original ticket.

(5) Engineering reviews the recording and plans next steps The replay link contains everything Engineering needs to fully understand the problem: user actions, UI state, visible errors, and system-level telemetry.
Multiplayer automatically includes backend traces, logs, and request/response data linked to the session.

Frontend developers, backend developers, and QA can all collaborate in one view to determine the root cause and fix.

(6) The issue is resolved faster Engineering doesn’t need to gather missing context or ask Support for more data. It’s all already captured.
They can move straight to diagnosing and fixing the issue.

Support stays in the loop, Engineering stays focused, and the user gets a clear, timely resolution.

Example: How Engineering teams work with Multiplayer​

Flowchart of support workflow

(1) A developer notices (or is alerted about) a bug A developer encounters an issue while working and, to quickly understand the undelying system behaviour, they record a full stack session recording using one these options:

From the Multiplayer UI can also set up session recordings to be captures automatically based on conditions they define (i.e.conditional recording mode). This would allow them to:

  • Get proactively notified when Multiplayer detects an error or exception
  • Understand how the system behaves for different user cohorts, environment, etc.

(2) The developer captures the bug with a full-stack session recording When using the in-app widget, browser extension or CLI app, they choose between two recording modes:

  • On-demand recording: Start and stop manually for full control
  • Continuous recording: Record in the background and automatically save sessions containing frontend or backend errors and exceptions

(3) Engineering teams review and annotate the recording Once captured, the recording appears in the Multiplayer UI, where teams can inspect both frontend and backend data — including traces, logs, requests/responses content and headers from deep within the system — all correlated within a single timeline.

Developers and QA can annotate sessions, highlight anomalies, and add notes to individual data points (APIs, errors, spans, traces, etc.) for discussion or handoff.

(4) Developer uses the recording to fix the bug Developers can:

  • Reproduce the issue locally using the session data
  • Feed the full session context to their IDE or AI assistant via the Multiplayer MCP server
  • Or manually investigate and code a fix using the replay and correlated telemetry

Each approach starts from the same shared session, reducing time spent gathering or verifying context.

(5) Visibility across all sessions Through the Multiplayer UI, developers aren’t limited to their own recordings.
They can see all session recordings captured across the entire application — whether triggered manually, continuously, or conditionally.

This visibility allows them to:

  • Spot recurring errors or performance patterns
  • Identify potential problems proactively
  • Leverage Multiplayer’s (beta) issue grouping feature, which clusters similar sessions to help surface systemic issues earlier

Next steps​

👀 If this is the first time you’ve heard about us, you may want to see full stack session recordings in action. You can do that in our free sandbox: sandbox.multiplayer.app

🚀 If you’re ready to trial Multiplayer, the fastest way to get started is to install our browser extension from the Chrome Web Store (Chrome, Firefox, and Edge supported).