Team Shared Inboxes: Real-Time Email Collaboration for QA
Create shared disposable inboxes that your entire QA team can view in real-time. Live presence indicators show who's online, read receipts track who's seen each message, and WebSocket connections deliver emails instantly.
6 min read
QA testing with email is painful when everyone on the team uses separate inboxes. Someone signs up, waits for the verification code, copies it into Slack, and the rest of the team has no idea what happened. With shared inboxes, every team member sees the same emails in real-time. No copying, no screenshots, no missed messages.
Team Shared Inboxes are available on Business plans. They use WebSocket connections through Cloudflare Durable Objects for instant delivery, live presence, and message-level read receipts.
Creating a Team
Start by creating a team workspace and inviting your colleagues. Business accounts can create up to 5 teams with 25 members each.
// setup-team.ts
import { Dissolve } from "@dissolve-email/sdk";
const dissolve = new Dissolve({ apiKey: process.env.DISSOLVE_API_KEY });
// Create a QA team workspace
const team = await dissolve.teams.create({
name: "QA Team",
});
// Invite team members by email
await dissolve.teams.invite(team.id, {
email: "alice@company.com",
role: "admin", // can manage members and inboxes
});
await dissolve.teams.invite(team.id, {
email: "sam@company.com",
role: "member", // can view shared inboxes
});
Team members are invited by email. They'll receive an invitation and join the workspace once they accept. Three roles control what each member can do:
// roles.ts
// Team roles and their permissions
//
// Owner - full control: manage team, members, inboxes, billing
// Admin - manage members and shared inboxes
// Member - view shared inboxes and messages (read-only)
//
// Business plan supports:
// - Up to 5 teams per account
// - Up to 25 members per team
// - Shared inboxes with real-time collaboration
// - Live presence indicators
// - Read receipts per message
Sharing Inboxes
Any inbox you create can be shared with one or more teams. Once shared, all team members can see the inbox and its messages in real-time.
// share-inbox.ts
// Create an inbox and share it with the team
const inbox = await dissolve.inboxes.create({
name: "qa-signup-test",
domain: "dissolve.email",
});
// Share the inbox with your team
await dissolve.inboxes.share(inbox.id, {
teamId: team.id,
});
// All team members can now see this inbox
// and receive real-time updates via WebSocket
Shared inboxes behave exactly like personal ones. Emails are delivered, stored, and expire on the same schedule. The difference is that everyone on the team sees them simultaneously.
Live Presence and Read Receipts
When a team member opens a shared inbox, a WebSocket connection is established through Cloudflare Durable Objects. This connection powers three real-time features:
- Presence indicators: see who's currently viewing the inbox with online/away status
- Real-time message delivery: new emails appear instantly for all connected team members
- Read receipts: track which team members have read each message, with timestamps
// real-time-events.ts
// Team members get live presence indicators
// The WebSocket connection shows who's viewing the inbox
// When Alice opens the shared inbox:
// { "type": "presence", "users": [
// { "name": "Alice", "role": "admin", "status": "online" },
// { "name": "Sam", "role": "member", "status": "online" }
// ]}
// Read receipts track who has seen each message:
// { "type": "read_receipt",
// "messageId": "msg_abc123",
// "readBy": ["Alice", "Sam"],
// "readAt": "2026-02-27T10:15:00Z"
// }
Read receipt history is retained for 7 days before automatic cleanup. This gives your team enough time to review test results without accumulating stale data.
CI/CD Integration with Playwright
The real power of shared inboxes is in automated testing. Your CI pipeline creates a shared inbox for each test run, and the QA team can watch the test execute in real-time from the dissolve.email dashboard.
// test/signup.spec.ts
// CI/CD integration - each test run gets its own shared inbox
import { test, expect } from "@playwright/test";
import { Dissolve } from "@dissolve-email/sdk";
const dissolve = new Dissolve({ apiKey: process.env.DISSOLVE_API_KEY });
test("team signup flow", async ({ page }) => {
// Create a shared inbox for this test run
const inbox = await dissolve.inboxes.create({
name: `ci-${Date.now()}`,
domain: "dissolve.email",
});
// Share with the QA team so they can watch live
await dissolve.inboxes.share(inbox.id, {
teamId: "team_qa",
});
// Run the signup flow
await page.goto("/signup");
await page.fill("[name=email]", inbox.address);
await page.fill("[name=password]", "TestP@ss123!");
await page.click("button[type=submit]");
// Wait for the verification email
const messages = await dissolve.messages.list(inbox.id);
// Team members can see this email arrive in real-time
expect(messages.length).toBeGreaterThan(0);
expect(messages[0].subject).toContain("Verify");
});
Because each test run creates its own inbox, there's zero state leakage between runs. The team can observe the current run while previous inboxes expire automatically.
Why Not Just Use a Shared Gmail?
Teams often start with a shared Gmail or Outlook account for QA testing. Here's why that breaks down:
- State pollution: old test emails accumulate and it's impossible to tell which run a message belongs to
- Password sharing: everyone needs the same credentials, which is a security risk and triggers 2FA challenges
- No isolation: two test runs sending to the same address will see each other's emails
- No API access: you can't programmatically create or read from a shared Gmail account in CI
- Rate limits: Google flags accounts that receive high volumes of verification emails
Shared disposable inboxes solve all of these. Each test gets a fresh, isolated inbox that the team can monitor in real-time, and it cleans itself up when the test is done.
Team Use Cases
- QA sprint testing: the team shares a single inbox while testing a signup flow, everyone sees the same emails
- Customer support debugging: reproduce a customer's email issue in a shared inbox so the entire support team can investigate
- Onboarding review: product managers watch the actual email a new user receives during signup, in real-time
- CI monitoring: share CI test inboxes so the team can watch automated tests execute live
- Multi-service testing: create multiple shared inboxes for different services (Stripe, GitHub, Auth0) and assign each to the relevant team
Plan Details
Team workspaces and shared inboxes are exclusive to the Business plan:
- Up to 5 teams per account
- Up to 25 members per team
- 50 concurrent inboxes with 60-minute lifetime
- Real-time delivery via SSE and WebSocket
- Live presence and read receipts
- Priority support for your team
- $15/month or $144/year (20% discount)
Get Started
Upgrade to Business to create your first team workspace. Invite your QA team, create a shared inbox, and see how real-time collaboration changes your testing workflow. Need help getting set up? Contact us or open a support ticket from your dashboard.
Try it while you read
A disposable inbox takes one press on the home page. No signup.
Keep reading
Product updates
Inbox Rules: Automate Email Forwarding, Labels, and Filtering
Automate your disposable inbox with rules that forward emails to your personal address, apply custom labels, or auto-delete spam. Configure up to 50 rules per account with regex pattern matching.
6 min read
Product updates
AI Agent Identities: Automate Signups for Cursor & AI Tools
Instantly create temporary email + password identity pairs for your AI agents. Automate signup flows, extract verification codes, and let Cursor, Claude, or any AI tool operate independently. No human inbox needed.
9 min read
Product updates
Introducing dissolve.email Browser Extensions
Our new browser extensions for Chrome and Firefox make creating temporary email addresses faster than ever. One click, instant privacy.
3 min read