Real-time sync in SalesSheet is scoped to your organization. When any team member changes a contact, opportunity, task, or activity, every other member sees the update instantly -- no refreshing needed. This keeps your entire team working from the same up-to-date data at all times.
Unlike traditional CRMs that require manual refreshes or periodic polling to see changes made by teammates, SalesSheet pushes updates to every connected browser the moment they happen. Whether a colleague updates a deal value, logs a call, or adds a new contact, you see the change reflected in your grid, detail pages, and dashboards within milliseconds.
How Real-Time Sync Works
Org-Scoped Subscriptions
SalesSheet uses Supabase real-time subscriptions scoped to your organization_id. When you log in, your browser opens a persistent WebSocket connection to the Supabase real-time server. This connection subscribes to a channel specific to your organization, which means you receive updates for all data within your org -- not just records you created or own.
The subscription is established automatically when you load SalesSheet. You do not need to configure anything or enable any settings. As long as your browser tab is open and you have an active internet connection, real-time updates flow to your screen.
How the subscription pipeline works:
- A team member makes a change (e.g., updates a contact's email address)
- The change is saved to the database
- Supabase detects the database change and broadcasts an event on the organization's real-time channel
- Every connected browser subscribed to that channel receives the event
- SalesSheet's front-end updates the affected record in the UI without a page reload
What Syncs in Real-Time
The following record types are covered by real-time sync. Any insert, update, or delete operation on these records is broadcast to all organization members:
- Contacts: New contacts added by any team member, field updates (email, phone, status, tags, custom fields), and deletions. If a colleague edits a contact you are currently viewing, you see the fields update live on your screen.
- Opportunities: Stage changes, deal value updates, new opportunities, close date modifications, and owner reassignments. The pipeline board and grid both reflect changes immediately.
- Tasks: Task completions, new task assignments, due date changes, priority updates, and status transitions. If you are looking at a shared task list, completed items are checked off in real time as teammates finish them.
- Activities: New calls logged, emails synced, notes added, and meetings recorded. The activity timeline on contact and opportunity pages updates live as new entries are created.
- Companies: Company record updates, new companies created through contact enrichment or manual entry, and field changes.
What Does Not Sync in Real-Time
User preferences, saved views, and personal settings are scoped to your individual account and do not broadcast to other team members. Dashboard widget configurations and notification preferences are also per-user. These settings are fetched fresh each time you log in but are not pushed via WebSocket.
Real-Time Channels and Architecture
Under the hood, SalesSheet uses Supabase Realtime channels to deliver updates efficiently. Here is how the channel architecture is structured:
- Organization channel: Each organization has a dedicated real-time channel identified by its organization_id. All team members in the same organization subscribe to this single channel.
- Event types: The channel carries three event types -- INSERT, UPDATE, and DELETE -- corresponding to the database operations performed on synced tables.
- Payload: Each event includes the affected record's table name, the new row data (for inserts and updates), and the record ID (for deletes). The front-end uses this payload to patch the local state without re-fetching the entire dataset.
- Filtering: Although all events for the organization flow through a single channel, the front-end applies client-side filtering to update only the views and components that are relevant to the changed data. For example, if you are on the Contacts page and an opportunity is updated, the contact grid does not unnecessarily re-render.
Dedup Window and Echo Prevention
The dedup window prevents echo updates -- when you make a change, you will not get a duplicate notification about your own update. Here is how it works:
- When you save a change, SalesSheet records a short dedup key containing the record ID and a timestamp
- When an incoming real-time event matches a recent dedup key, the event is silently discarded on the client side
- This window lasts approximately two seconds, which is enough time for the round trip from your save action to the broadcast event
- The result is that you never see a flash or flicker from your own changes being re-applied, but you still receive updates from every other team member
The dedup system also coalesces rapid successive updates to the same record. If a teammate quickly edits multiple fields on a contact (say, updating both email and phone within a second), you may receive a single consolidated update rather than two separate events. This reduces UI churn and keeps the interface smooth.
Conflict Resolution
When two team members edit the same record at the same time, real-time sync ensures both changes are preserved. SalesSheet uses a last-write-wins strategy at the field level, not the record level. This means:
- If Alice updates a contact's email while Bob updates the same contact's phone number, both changes are saved -- there is no conflict because different fields were modified.
- If both Alice and Bob update the same field (e.g., both change the status), the last save wins and both users see the final value in real time. A small toast notification informs the user whose change was overwritten.
- The activity timeline records both changes with timestamps, so you always have a full audit trail of who changed what and when.
Offline Behavior and Reconnection
If your internet connection drops or your laptop goes to sleep, the WebSocket connection is interrupted. SalesSheet handles this gracefully:
- Automatic reconnection: When your connection is restored, SalesSheet automatically re-establishes the WebSocket subscription. You do not need to refresh the page.
- Catch-up fetch: After reconnecting, the app performs a background data refresh to fetch any changes that occurred while you were offline. This ensures you do not miss updates that were broadcast while your connection was down.
- Connection indicator: A small status indicator in the bottom corner of the app shows your real-time connection state. Green means connected; yellow means reconnecting; red means disconnected.
- Queued changes: If you make edits while offline, they are queued locally and submitted once the connection is restored. The dedup window ensures these do not create echo events.
Performance Considerations
Real-time sync is designed to be lightweight and should not noticeably impact your browser performance, even on larger teams. Here are some details about resource usage:
- Bandwidth: Each real-time event is a small JSON payload, typically under 2 KB. Even on a busy team making dozens of updates per minute, the total bandwidth consumed is negligible.
- CPU: Client-side processing of real-time events is minimal. The front-end patches the local data store and updates only the affected UI components using efficient diffing.
- Scaling: Supabase real-time channels are built on Phoenix (Elixir) and support thousands of concurrent connections per channel. Organizations with up to several hundred team members should experience no degradation.
- Battery: On laptops and mobile devices, the WebSocket connection uses very little power. It is a persistent idle connection that only transmits data when an event occurs.
Pro Tip
Real-time sync is especially valuable during team selling scenarios. When one rep updates a deal stage, the account executive sees it immediately and can adjust their approach accordingly. During live pipeline reviews, everyone in the meeting sees changes as they are made, eliminating the need for screen sharing or constant page refreshing.
Troubleshooting
I am not seeing updates from my teammates. What should I check?
First, check the connection indicator in the bottom corner of the app. If it is red or yellow, your WebSocket connection may be down. Try refreshing the page. If the issue persists, check your internet connection and ensure that your firewall or corporate network is not blocking WebSocket connections to Supabase (wss://*.supabase.co).
I see my own changes appearing as notifications. Is that normal?
No -- the dedup window should prevent this. If you are seeing echo notifications for your own changes, try refreshing the page to reset the dedup state. This can occasionally happen if your browser clock is significantly out of sync or if the page has been open for an extended period without a refresh.
Does real-time sync work across multiple browser tabs?
Yes. Each open tab maintains its own WebSocket connection and receives real-time events independently. If you have the contacts grid open in one tab and a contact detail page in another, both tabs update when a change is made. However, opening many tabs increases the number of active connections, so we recommend keeping it to a few tabs for optimal performance.
Can I disable real-time sync?
Real-time sync cannot be disabled because it is a core part of how SalesSheet keeps team data consistent. If you are experiencing performance issues that you believe are related to real-time sync, please contact support so we can investigate.