Migration Playbook: Moving Your Team From Meta Workrooms to Horizon or WebRTC

Immediate playbook for IT: keep meetings running when Meta shutters Workrooms

If your org used Meta Workrooms for VR meetings, you face a hard deadline: Meta discontinued the standalone Workrooms app on February 16, 2026. That means admins need a short, prioritized migration plan that preserves meeting continuity, exports critical data, retires Quest device management safely, and implements a browser-based WebRTC fallback so teams don’t lose access when participants can’t use Horizon or a Quest headset.

Why this matters now (2026 context)

By late 2025 Meta shifted Reality Labs strategy and consolidated platform features into Horizon. Many enterprises that standardized on Workrooms for distributed team collaboration now must move or re-architect quickly. At the same time, organizations are prioritizing hybrid-first collaboration stacks and low-friction browser fallbacks—trends that accelerated across 2024–2026 as WebRTC ecosystems matured and companies adopted SFU-based scalable audio/video solutions.

Top-line migration checklist (do this first)

1. Audit all Workrooms assets, spaces, recordings, and device inventory.
2. Export meeting recordings, chat logs, and participant data before the shutdown window closes.
3. Decide whether to move to Horizon or to a hybrid approach (Horizon + WebRTC fallback).
4. Build a WebRTC fallback for non-headset attendees or last-minute access.
5. Communicate timelines and provide runbooks for end users and helpdesk staff.
6. Test the new flow end-to-end—recordings, permissions, SSO, and headset enrollment.

Step 1 — Audit and inventory (30–72 hours)

Start with a rapid discovery sprint. Capture everything you’ll need to move or preserve.

• List every team that used Workrooms and the frequency of meetings.
• Inventory Quest headsets: serial, firmware, MAC, current enrollment status (if you used Horizon managed services).
• Identify all recorded sessions, owner accounts, and retention requirements (legal, compliance).
• Map integrations: calendar (Google/Exchange), SSO (SAML/OIDC), Slack/MS Teams links, and file attachments.

Deliverable: a single spreadsheet with columns for team, owner, recording IDs, headset IDs, calendar IDs, and priority (high/medium/low).

Step 2 — Data export and retention (72 hours — 2 weeks)

Workrooms recordings and meeting metadata are the highest-risk data you can lose. Start exports immediately—don’t wait.

What to export

• Meeting recordings: video, audio, and any screen-share captures.
• Chat logs and whiteboard artifacts.
• Participant lists and timestamps.
• Configuration and space assets—any spatial layouts or persistent objects you may need to reconstruct in Horizon or another platform.

How to export (practical guidance)

1) Check admin portals and user account export tools: request personal data downloads for Workrooms-related accounts.

2) If Workrooms recordings were linked to owner accounts, instruct owners to download files locally (multiple attendees if necessary) and upload to the organization’s archival storage (S3, Azure Blob, or Google Cloud Storage).

3) Automate the upload and metadata capture with a small script. Example: use AWS CLI and a CSV manifest:

#!/bin/bash
# upload-manifest.sh
while IFS=, read -r owner local_path meeting_id; do
  aws s3 cp "$local_path" "s3://my-org-workrooms-archive/$meeting_id/" \
    --metadata Owner="$owner" --acl private
done < meetings-manifest.csv

4) For compliance, record export actions (who exported what and when) in your ticketing system.

Step 3 — Decide: move to Horizon or adopt a hybrid model

Meta positioned Horizon as the successor platform. Many organizations will migrate entirely to Horizon where possible. Others should plan a hybrid approach: Horizon for Quest-native experiences and a browser WebRTC fallback for those on laptops, mobile, or non-Quest VR devices.

• If your org requires deep VR spatial features, prioritize Horizon migration and rebuild key spaces there.
• If your org needs the broadest accessibility and lower friction, build a WebRTC fallback first and integrate Horizon where available.

Step 4 — Admin tasks for Horizon and Quest headsets

Horizon’s managed services were being consolidated; your options in 2026 may require using a mix of vendor-provided tools and third-party MDMs. Key admin tasks:

1. Update device OS and firmware so users aren’t blocked by incompatible updates during migration.
2. Re-enroll headsets under your new Horizon or enterprise account model—document the new enrollment process for IT and users.
3. SSO and provisioning: test SAML/OIDC flows and group entitlements for Horizon spaces.
4. Network and firewall rules: ensure outbound access to Horizon servers and required STUN/TURN services. Whitelist STUN/TURN IPs or FQDNs where possible.
5. Policy and data retention: align Horizon space lifecycle with your retention requirements and export policies.

Deliverable: an admin runbook with enrollment steps, network checklist, and rollback steps.

Step 5 — Build a WebRTC fallback: architecture and sample implementation

A WebRTC fallback preserves meeting continuity when users can’t join via Quest/Horizon. The minimal reliable architecture contains:

• Browser client for audio/video and screen-share (React or plain JS).
• Signaling server (WebSocket) to exchange SDP and candidate messages.
• SFU (optional but recommended) such as mediasoup, Janus, or Jitsi Videobridge for group scaling and bandwidth efficiency.
• TURN server for connectivity behind symmetric NATs (coturn).
• Auth: short-lived tokens or SSO integration to match meeting identities to your directory.

Minimum viable fallback (no SFU)

For small teams (up to 4), you can implement peer-to-peer mesh WebRTC with a simple signaling server. Example signaling server in Node.js (ws):

// simple-signaling.js (Node.js)
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
  ws.on('message', (msg) => {
    // broadcast to other clients
    wss.clients.forEach((client) => {
      if (client !== ws && client.readyState === WebSocket.OPEN) client.send(msg);
    });
  });
});

Browser client snippet (basic peer connection and getUserMedia):

// client.js
const pc = new RTCPeerConnection();
const ws = new WebSocket('wss://signaling.example.com');

navigator.mediaDevices.getUserMedia({ audio: true, video: true }).then(stream => {
  stream.getTracks().forEach(track => pc.addTrack(track, stream));
  document.querySelector('#localVideo').srcObject = stream;
});

pc.ontrack = (e) => { document.querySelector('#remoteVideo').srcObject = e.streams[0]; };

ws.onmessage = async (event) => {
  const msg = JSON.parse(event.data);
  if (msg.sdp) await pc.setRemoteDescription(msg.sdp);
  if (msg.candidate) await pc.addIceCandidate(msg.candidate);
};

pc.onicecandidate = (e) => { if (e.candidate) ws.send(JSON.stringify({ candidate: e.candidate })); };

Note: P2P mesh will not scale; add an SFU for larger meetings and better CPU/network efficiency.

SFU-based production pattern (recommended)

For teams larger than 6–8 participants, deploy an SFU like mediasoup or Janus. Key benefits: selective forwarding, lower client CPU and bandwidth, ability to record centrally.

High-level steps:

1. Provision a TURN server (coturn) and configure on both SFU and clients.
2. Deploy SFU containers (K8s) with autoscaling policies matching meeting concurrency.
3. Integrate auth: issue per-meeting tokens that the signaling server verifies before admitting participants.
4. Add server-side recording: SFUs can provide hooks to capture RTP streams to files (for archival and compliance).

Step 6 — Meeting continuity: calendars, invites, and fallbacks

People won’t remember to switch apps mid-meeting. Implement these UX-safe guards:

• Create calendar invites that include both the Horizon join link and the WebRTC fallback URL. Keep both prominent in the description.
• Implement automatic redirect logic on the fallback landing page: if a user’s browser detects a compatible Quest UA or Horizon protocol handler, offer the native path; otherwise load the browser client.
• Use meeting tokens in URLs (short-lived) so shared links don’t become a security risk.
• Provide a single-click “Join via Browser” button on all meeting pages for users without headsets.

Step 7 — Testing, QA, and go-live checklist

Before decommissioning Workrooms, run a staged cutover:

1. Run pilot meetings with each team type (design, engineering, exec) and collect feedback.
2. Test SSO, guest access, and permission boundaries.
3. Validate recording capture in both Horizon and WebRTC flows and confirm exports land in archival storage.
4. Conduct stress tests for expected concurrent meetings and attendees—especially if using an SFU.
5. Confirm device policies and MDM re-enrollment on at least 20% of headsets across geographies.

Troubleshooting guide (common issues and fixes)

Issue: Participants can’t join because of NAT or firewall

Fixes:

• Check TURN server config and credentials. Test with coturn diagnostics.
• Open/allow outbound UDP 3478 and TCP 5349 and typical STUN/TURN ports; allow WebSocket ports used by signaling.

Issue: Recordings missing or corrupted after export

Fixes:

• Verify MD5/sha256 checksums during upload. Retain local copies until retention policy allows deletion.
• Use server-side transcoding tools (ffmpeg) to normalize codecs and containers.

Issue: Users confused by two join links (Horizon vs browser)

Fixes:

• Use a landing page that detects environment and surfaces the single best button to join.
• Provide a clear in-invite note: “If you don’t have a Quest headset, click Join via Browser.”

Security, compliance, and data governance

Migration is a chance to tighten data controls:

• Use enterprise SSO for both Horizon and your WebRTC fallback; enforce MFA for host accounts.
• Apply least-privilege roles for join links and recording access; use signed URLs for archived files.
• Log all exports and admin actions for audit trails (SIEM integration recommended).
• Retain recordings per policy and ensure secure deletion once retention expires.

Advanced strategies and future-proofing (2026+)

Based on 2025–2026 trends, here are advanced patterns to adopt:

• Hybrid rendering layers: build your WebRTC app to support spatial audio mixing on the client and stream positional metadata to Horizon where applicable.
• Microservices for meeting features: isolate recording, transcription, and moderation into separate services to swap vendors without large rewrites.
• AI-enhanced recordings: implement server-side transcription and meeting highlights; integrate with your knowledge base (confluence/Notion) automatically.
• Device lifecycle automation: use IaC/Kubernetes to scale SFUs and use MDM APIs to automate headset reclaims and reprovisioning.

Operational runbook: quick reference

• Day 0–3: Audit + priority recording export
• Day 3–14: Build and test WebRTC fallback (P2P), deploy TURN
• Day 14–30: Pilot SFU, integrate SSO, deploy recording to archive
• Day 30–45: Full-migrate calendars, update invites, decommission Workrooms paths
• Ongoing: Monitor usage, retention, and device enrollment status

Case study (example)

Engineering org X (300 people) used Workrooms for daily standups and design reviews. They followed this approach:

1. Exported two months of recordings (priority) within 5 days and archived to S3.
2. Launched a WebRTC fallback built on mediasoup for 1:many meetings and coturn for NAT traversal.
3. Migrated frequent collaborators to Horizon for VR-only design sessions and kept the browser fallback for cross-functional reviews.
4. Result: zero meeting cancellations after Workrooms shutdown and a 30% reduction in cross-platform join friction.

Final takeaways

When a vendor discontinues a productivity endpoint like Meta Workrooms, the key priorities are data preservation, meeting continuity, and low-friction access. In 2026, the best practice is a hybrid approach: move VR-first experiences to Horizon where necessary, and deploy a resilient WebRTC fallback to guarantee that any participant can join from a browser or mobile device.

Focus on fast exports, enrollment automation, and a simple, well-documented fallback landing page that routes users to the right experience. Add an SFU and TURN if you expect medium-to-large meeting sizes, and bake in SSO and recording governance from day one.

Resources and starter templates

• coturn setup guide (production TURN server)
• mediasoup quickstart for SFU deployments
• Signaling server templates (Node + WebSocket) and React client boilerplate
• ffmpeg snippets for standardizing archived recordings

Actionable step: Export your top 10 recorded meetings now, stash them in secure cloud storage, and publish a calendar invite template that includes both Horizon and browser join links.

Call to action

Start the migration checklist today: run the audit, export priority recordings, and spin up a WebRTC fallback in a development environment. Need a migration template or a turnkey WebRTC fallback starter? Contact our team for runbooks, scripts, and deployment templates tailored to your org’s size and compliance needs.

Related Reading

• Portable Bento Hacks: Budget-Friendly Commuter Meals for Tokyo Workers
• Securing Desktop Autonomous Agents: Permissions, Data Leak Prevention and Audit Trails
• From Graphic Novels to Screen: A Creator’s Guide to Building Transmedia IP Like The Orangery
• From Citrus Farms to Kebab Stands: Meet the Growers Behind Your Sauces
• Cold-Weather Skincare Shopping List: What to Buy at Local Convenience Stores vs. Specialty Shops