Tools & Resources
How We Built Real-Time Collaboration into a Seating Chart Tool (And What We Learned)
A technical but accessible look at building real-time collaboration for seating charts: how concurrent editing, automatic conflict resolution, and live sharing work under the hood, and why it matters for event professionals.
What happens when two people drag the same table at the same time? It's the question that keeps event-tool builders up at night.
It sounds academic. It isn't. If you're an event planner working on a floor plan with your venue coordinator, or a couple dividing up the seating chart on a Sunday evening, this is the exact moment your tool either works or breaks. One person moves Table 5 closer to the dance floor. The other reassigns a guest at Table 5 to Table 8. Both hit save. What does the chart look like now?
Most tools dodge this problem entirely. They give you single-user editing and a “share” button that exports a static PDF. Or they let multiple people open the chart, but the last person to save overwrites everyone else's work. We decided to solve it properly.
This post is for event professionals evaluating whether a cloud seating tool can actually handle your workflow. Not just a single person designing alone, but a team collaborating across locations, devices, and roles. I'll get into some technical detail, but the goal is to make clear what real-time collaboration actually means, how it works under the hood, and why the engineering choices matter in your daily work.
The Problem: Seating Charts Are a Team Sport
A seating chart is never a solo project. At minimum, two people have opinions about it. At a corporate gala, you have the event planner, the venue coordinator, and possibly a client who wants sign-off. At a wedding, you have the couple, maybe a parent or two, and the day-of coordinator who needs to know where the head table ends up.
The traditional workflow looks like this: one person creates the chart, exports a PDF, emails it to the next person, waits for feedback, makes changes, exports again. Three rounds of this and a week has gone by. If two people make changes to their own copies simultaneously, someone has to compare the copies and combine the changes by hand. At 150 guests, that takes a full afternoon.
The PDF Loop
Export, email, wait, get feedback, make changes, re-export, re-email. Repeat until someone loses track of which version is current.
The Overwrite Problem
Two people edit different copies. One saves. The other saves on top of it. Guest assignments vanish. Nobody notices until the rehearsal dinner.
The Screenshare Hack
“Let me share my screen and you tell me where to put things.” Works for 15 minutes. Falls apart when someone needs to step away and come back.
We wanted to eliminate all of this. The goal: two people open the same chart on different devices, and both can edit it simultaneously. Changes appear on the other screen in under a second. No exports, no version conflicts, no extra coordination.
Many seating tools still rely on file handoffs or desktop-only installs rather than true simultaneous editing. See SeatPlan.io vs PerfectTablePlan for a direct comparison, or browse all seating chart comparisons.
What “Real-Time” Actually Means
The phrase “real-time collaboration” gets thrown around loosely. Some tools mean “we auto-save every 30 seconds.” Others mean “you can see a cursor.” Here is what it means in SeatPlan.io:
Concurrent Editing
Multiple people edit simultaneously. You drag a table while your coordinator assigns guests. Both changes are applied instantly, without either of you waiting.
Sub-Second Sync
Changes travel over WebSocket connections and appear on other screens within milliseconds. Not after a page refresh. Not after hitting save. Immediately.
Automatic Conflict Resolution
If two people edit the same element at the same time, the system merges both changes automatically. No error popups. No “someone else is editing this” warnings. No data loss.
Presence Awareness
You can see who else is in the session. Collaborator avatars show up in the header, and connection status is always visible. You know when your coordinator joins and when they leave.
This is the same kind of experience you get in Google Docs, but applied to a visual, spatial tool where people are dragging objects around a canvas rather than typing text. The engineering challenge is fundamentally different, and that's where the interesting decisions come in.
The Hard Problem: What Happens When Edits Collide
Text is forgiving. If two people type in different paragraphs of the same document, merging is straightforward. A seating chart is spatial. Tables have x/y positions, guests have seat assignments, and moving one thing affects the logic of five others.
We evaluated three approaches before building:
Locking
Only one person can edit an element at a time. Simple to implement. Terrible experience. “Sorry, the coordinator is editing that table” is not a sentence anyone wants to read during a planning session.
Last Write Wins
Accept every change; the newest timestamp wins. Simple, but you silently lose work. You moved a table carefully, but your colleague's accidental drag two seconds later overwrites your position.
CRDTs
Conflict-free Replicated Data Types. A mathematical framework where every client can edit independently and changes always merge correctly. No coordination needed between clients. This is what we chose.
CRDTs, Without the Computer Science Lecture
Think of a CRDT as a data structure with a built-in referee. Each user has their own copy of the seating chart. When you make a change, it's applied to your copy first, so you see it instantly without waiting for the server. Then it's broadcast to everyone else. When a remote change arrives, the CRDT merges it into your local copy automatically.
The key property: it does not matter what order the changes arrive in. User A's change can arrive before or after User B's change, and the result is always the same. Both users always end up with the same chart. This is called eventual consistency, and it is the same principle that powers Google Docs, Figma, and other collaborative tools.
In practice, this means: You drag Table 5 to the left side of the room. At the same moment, your coordinator renames Table 5 to “VIP Lounge.” Both changes are accepted. You end up with a table called “VIP Lounge” on the left side of the room. Nobody's work is lost. Nobody gets an error message.
We built this on top of Yjs, an open-source CRDT library. Our seating chart data (tables, guests, special areas, chair rows, and all their properties) lives in a Yjs document that synchronizes across all connected clients via WebSocket. The architecture is serverless: AWS Lambda handles the connection management, and the CRDT logic runs on each client. There is no central server deciding “who wins.” Every client is an equal participant.
How It Works in Practice: Sharing a Live Link
The architecture only matters if it saves you time. Here's how real-time collaboration works when you use SeatPlan.io with a client or coordinator:
Generate a collaboration link
From your dashboard, click the share button on any event. SeatPlan.io generates a unique, secure link. You choose whether the recipient gets full editing access or view-only. You can set an expiration date.
Send it to your collaborator
Email it, text it, put it in a Slack message. Your venue coordinator clicks the link and they're in. They don't create an account, install software, or download an app. They see the live chart immediately.
Edit together, live
Both of you see the same chart. Drag a table, and it moves on their screen. They assign a guest, and it updates on yours. Collaborator avatars in the header show who is currently in the session. There is no “save” button. Changes save automatically.
Export when ready
When you are both satisfied, either of you can export a PDF of the floor plan or an Excel guest list. The export reflects the live state of the chart, so it's always current and never a stale snapshot.
This replaces the PDF email chain entirely. Your coordinator can review the chart from a tablet during a site visit, move the head table to where it actually fits, and you see the change on your laptop at home in real time. You discuss and edit one chart, with no confusion over versions.
Permissions: Giving Your Client Access Without Giving Them the Keys
Sometimes you don't want everyone to have the same level of control. A venue coordinator who is helping with layout should probably not be reassigning the bride's family to a different table. A client reviewing a corporate gala chart should be able to see everything but might only need to move a few specific elements.
SeatPlan.io's Event & Venue Manager tier supports two levels of permission control:
Session-Level Access
Set a collaborator to view-only and they can see the entire chart, zoom, pan, and review guest assignments, but they can't move or change anything. Ideal for client sign-off reviews.
Element-Level Locking
Lock individual tables, special areas, or chair rows. The collaborator can edit everything else freely, but locked elements stay put. Use this when the venue has fixed constraints, like a bar position or a head table that can't move.
Permissions are enforced at the data level, not just the UI. A view-only collaborator cannot send edit commands to the server even if they try. If you share charts with people outside your team, that matters. The access controls are real, not cosmetic.
Under the Hood: The Engineering Choices That Matter
You don't need to understand the engineering to use the tool. But if you're evaluating SeatPlan.io for a professional operation, or you're a developer curious about how it works, here are the decisions that shaped the system.
Optimistic UI: Local-First Updates
When you drag a table, the move happens on your screen immediately. It does not wait for a server round-trip. The change is applied to your local CRDT document first, then broadcast to other clients. This is why the tool feels fast even on slower connections. Your actions never wait for a network response.
Atomic Mutations for Complex Operations
Swapping two seated guests isn't a simple operation. It means updating two tables and two guest records. We batch these into atomic mutations that execute together, minimizing the window where another user could see an inconsistent intermediate state. Guest A doesn't briefly disappear before reappearing at the new table.
Serverless WebSocket Architecture
The collaboration backend runs on AWS Lambda with API Gateway WebSockets. There's no server left running and costing money when nobody is editing. When you open a session, a Lambda function spins up to manage the room. When everyone disconnects, it shuts down. You pay for what you use.
Bridge Pattern: Two Type Systems
Internally, the CRDT uses a Map-of-Maps structure optimized for conflict resolution. Externally, the React UI works with domain types like Table, Guest, and SpecialArea. A bridge layer converts between the two in real time, so the UI always renders clean domain objects while the CRDT keeps data consistent across clients.
Why this matters for event professionals: These choices affect your work. Optimistic UI means the tool feels instant even on hotel Wi-Fi during a site visit. Atomic mutations mean a guest swap does not flicker mid-operation. Serverless means the system scales to handle a venue's busiest season without us (or you) worrying about infrastructure.
What We Learned Building This
Building real-time collaboration into a spatial tool is hard. Here are the lessons that might help whether you're evaluating tools or building your own.
Collaboration is not an add-on
You cannot bolt real-time onto a single-user tool. Every state change, every mutation, every save has to be designed with multiple concurrent users in mind from the start. We rebuilt our entire state management layer to make this work.
Spatial is harder than text
Text collaboration (Google Docs-style) has decades of research behind it. Spatial collaboration, where objects have positions, sizes, and relationships to each other, has far less. Every edge case we found was new.
Presence is half the value
Seeing that your coordinator is online and active in the session is almost as valuable as the concurrent editing itself. It turns a back-and-forth with delays between replies into a live working session. Users spend less time on email and more time on the chart.
Permissions need nuance
Binary access (edit or view) is not enough. Event professionals need element-level control: “yes, they can rearrange the lounge area, but the head table stays where I put it.” Granular permissions take longer to build but match how people actually work.
The biggest lesson: Real-time collaboration is not a feature. It is a different way of working. Once people have edited a chart together live, with no email loop, no version tracking, and no “wait, which file is current?”, they don't go back. It is the kind of thing that feels like a nice-to-have until you use it, and then it becomes non-negotiable.
Two Collaboration Models: Couples and Professionals
We built two distinct collaboration experiences because couples and professional event planners have different needs:
Collaborate (for Couples)
Invite a partner, parent, or friend to co-edit your seating chart. Everyone gets full editing access. There are no separate roles. Share a link and start dragging. Designed for couples planning from different rooms, or even different cities.
Event & Venue Manager (for Professionals)
Invite clients and coordinators with granular permissions. Set view-only access for reviews. Lock specific elements. Manage multiple events from a single dashboard. Designed for venues, planners, and agencies managing a portfolio of events.
Both tiers use the same underlying CRDT engine. The difference is in the permissions and the way you use the tool. A couple does not need element locking or client access controls. A venue coordinator managing fifteen events per month does.
Frequently Asked Questions
See Real-Time Collaboration in Action
Stop emailing PDFs back and forth. Open a chart, share a link, and design your seating plan together, live. Whether you're a couple splitting the guest list or an event planner working with a venue, you should see each other's changes instantly, without sending revisions back and forth.
Free to design. Collaborate on the Collaborate or Event & Venue Manager tier.