Multiple people, one relational document, no lost work.
Google-Docs-style co-editing over multi-table enterprise data: an invoice with its lines and references, edited live by several users, committed in one transaction.
- ·Several people can work on one multi-table document at the same time, an invoice with its lines and references, and see each other's changes live.
- ·If an integration changes the underlying row mid-session, the change merges in under per-field rules, and a field the user deliberately edited is never silently overwritten.
- ·Save commits the whole document in one transaction in foreign-key-safe order, so there is no half-saved state to clean up.
Flat documents got collaboration. Enterprise data didn't.
Real-time co-editing is normal for documents and spreadsheets. Enterprise records still live behind single-user forms with save conflicts, lock columns, and the occasional overwritten hour of work.
The hard part is that an enterprise document isn't flat. An invoice is a tree: header, lines, parties, references, several foreign-key levels deep. Making that co-editable with conflict handling and transactional integrity is the kind of thing teams estimate in quarters, which is why almost nobody builds it.
The mechanisms, not the adjectives.
Draft mirrors with live sync
Edits land in mirror tables and broadcast to every connected editor over SignalR in real time. Presence is visible: you can see who else is in the document.
Two people preparing the same invoice is a feature, not a support ticket.
External-change detection
Database triggers detect when a watched row is changed outside the draft pipeline, by an integration or an admin tool. A sync service merges the change in under a per-column rule: a field the user deliberately edited is never silently overwritten.
The system tells you the source row moved while you were editing, at edit time, while you're still there to decide.
Transactional, FK-ordered save
Save commits the whole multi-table document in a single SQL transaction with strict foreign-key-safe ordering: deletes leaf to root, inserts root to leaf. A mid-save failure can't leave half a document behind.
The document is either committed or it isn't. There is no in-between state to clean up.
Security all the way through
Draft editing inherits the source table's tenant scoping and permission keys. Collaboration doesn't open a side door around the security engine.
The convenience features obey the same rules as everything else. That's the point of one data path.
Two editors, one integration, zero lost keystrokes.
- 1
Two users open the same invoice. Each sees the other's presence and edits appear live.
- 2
An overnight integration updates the source row mid-session. The trigger catches it and the sync service merges it in.
- 3
One field was already edited by a user this session. That field keeps the user's value and the conflict is flagged for a human decision.
- 4
Save commits the header, lines, and references in one transaction, in dependency order.
- 5
The audit trail shows who changed what, including the integration's contribution.
The AI angle.
The same pipeline that merges a colleague's edits can merge an agent's. An AI that drafts invoice lines or fills defaults works inside a draft, visibly, with the same per-field conflict rules, and a human commits the result. That's a much safer shape for agentic work than letting a model write directly to production tables.
Keep going.
Data & instant API
Register a table and it is secured, audited, and queryable. No ORM, no per-table code.
Go deeper →Integration & automation
Background automation that obeys the same tenant boundaries as interactive users.
Go deeper →Operations
The platform ships with its own ops console, real-time notifications, and full change history.
Go deeper →See it on your schema, not ours.
A fixed-price assessment gets this running over your actual data.