- 6 minutes to read

Multi-User Collaboration – Real-Time Editing and Team Workflows

New .7.x

Multi-User Collaboration in Nodinite Mapify enables distributed teams to work concurrently on integration landscapes with confidence. Multiple users can view, edit, and annotate the same Repository Model entities simultaneously, with real-time updates ensuring everyone sees the latest changes instantly. Whether your team is conducting root-cause analysis, planning new integrations, or documenting existing architectures, Mapify's collaboration features eliminate version conflicts and "stepped-on-each-other's-toes" scenarios.

Note: Multi-User Collaboration requires Mapify Premium licensing and Nodinite Web API 7.x. Contact Nodinite Sales to enable this feature.

Why Multi-User Collaboration?

  • No accidental overwrites – Conflict detection prevents two users from silently overwriting each other's changes
  • Global team coordination – Real-time updates keep distributed teams synchronized
  • Complete audit trails – Track who changed what, when, and why for compliance and governance
  • Contextual discussions – Comment directly on entities to resolve questions without meetings
  • Faster onboarding – New team members can review live edits and historical comment threads

Collaboration Principles

Mapify's multi-user collaboration is built on four core principles:

1. Transparency – Know Who's Working Where

User presence indicators show who is currently viewing or editing each entity in real-time. See active users, their current focus area, and recent changes at a glance via avatar badges on nodes and an activity panel.

2. Real-Time Synchronization – Always See Latest Data

Changes made by any user are instantly propagated to all connected clients via WebSocket/SignalR — no page refreshes, no stale data, no confusion. Visual toast notifications appear for relevant updates.

3. Conflict Prevention – Protect Everyone's Work

Optimistic locking allows concurrent editing while detecting and resolving conflicts gracefully. Conflicts are resolved via user dialog (keep / overwrite / cancel), with undo capability for overwritten changes.

4. Complete Audit Trail – Know What Changed and Why

Every change is tracked with full metadata: who, what, when, and optionally why (via commit messages or comments). Changes are queryable, exportable, and compliant with SOX, GDPR, and HIPAA requirements.

Concurrent Editing Scenarios

Scenario 1: Non-Conflicting Edits (Ideal Case)

Alice edits Description and Bob edits Owner on the same entity simultaneously. Mapify merges field-level changes automatically — both users see all updates applied with a success notification.

Scenario 2: Conflicting Edits (Same Field)

Alice changes Status to "Deprecated"; Bob changes Status to "In Review" at the same time. Alice saves first. Bob sees a conflict dialog with his change vs. Alice's change, and chooses: keep Alice's / overwrite / cancel. Alice is notified if Bob overwrites her change, with a one-click undo option.

Scenario 3: High-Frequency Edits

Five users edit different fields within 10 seconds. All changes are applied in server arrival order. Each user sees incremental real-time updates. An "Activity panel" shows who edited what.

Scenario 4: Offline Editing and Sync-on-Reconnect

Alice loses internet connectivity while editing. Mapify detects disconnection and displays an Offline Mode banner. Alice continues editing; changes are queued in browser IndexedDB. On reconnection, Mapify automatically syncs local changes — showing a conflict dialog if other users also changed the same fields while Alice was offline.

Architecture and Presence Indicators (Spoke)

Technical design of the real-time system: SignalR WebSocket architecture, update flow, optimistic vs. pessimistic locking comparison, and user presence indicators on graph nodes and activity panel.

  • System: Client → Web API → Redis + SQL Server + Message Queue → SignalR broadcast
  • Presence: Avatar badges show editing/viewing/commenting state; auto-cleared after 15 minutes idle

See Architecture and Presence Indicators for complete Mermaid diagram, C# locking implementation, conflict dialog JS, and presence HTML/CSS.

Scalability and Offline Editing (Spoke)

Offline editing support and infrastructure guidance:

  • Horizontal scaling: Azure SignalR Service with Redis backplane; stateless Web API
  • Offline editing: IndexedDB change queue; auto sync-on-reconnect; field-level conflict resolution UI

See Scalability and Offline Editing for C# Azure SignalR config, SQL index examples, Redis caching code, and offline sync JavaScript.

Change Tracking and Audit Trail (Spoke)

Complete field-level change history for every Repository Model entity:

  • Entity metadata: CreatedBy, LastModifiedBy, RowVersion, ModificationCount on every entity
  • EntityChangeLog table: Entity-type, field name, old/new value, changed-by, timestamp, IP address, session ID
  • Change history timeline: Visual UI with avatars, diff display (red/green), revert button
  • Filter queries: modified:7d, lastModifiedBy:alice@..., modificationCount:>10

See Change Tracking and Audit Trail for full SQL schema, JSON API response, timeline HTML/CSS, and filter UI.

Audit Reports and Retention (Spoke)

Compliance reports, data retention policies, SQL queries, and GDPR deletion workflows:

  • 4 report types: Change Activity (Excel with C# EPPlus code), User Activity, Compliance Audit (filtered SQL), High-Risk Changes
  • Retention policies: Production 365 days, Test 90 days, Dev 30 days — configurable with compliance overrides (SOX 7 years, HIPAA 6 years)
  • GDPR deletion: Anonymize ChangedBy → "User_DELETED_20260119"; preserve change metadata; generate deletion certificate

See Audit Reports and Retention for Excel generation code, SQL query examples, retention configuration, and GDPR anonymization script.

Comments and Annotations (Spoke)

Collaborative annotations directly on integration entities:

  • Data model: 15 fields including threading (ParentCommentId), status, MentionedUsers JSON array, soft delete
  • @mentions: @alice.johnson autocomplete with fuzzy matching; email + in-app notifications; user notification preferences
  • Threads: Max 3 levels deep; 20px indentation per level; visual border-left thread line

See Comments and Annotations for DB schema, API JSON examples, @mention autocomplete HTML, notification template, and threading CSS.

Comment Status and UI (Spoke)

Comment status workflow and UI display options:

  • Status lifecycle: Open (blue ) → Resolved (green ) ↔ Closed (gray ) with reopen capability
  • 3 display modes: Inline badge on node, side panel (entity details + comments), modal dialog (full-focus)
  • Use cases: Compliance approval, incident root-cause, architecture decisions, change coordination
  • WCAG 2.1 AA: All status colors meet 4.5:1 contrast ratio; status shown by icon + text + color; full keyboard and screen reader support

See Comment Status and UI for Mermaid state diagram, all 3 display UI HTML/CSS, use case step-by-steps, best practices, and accessibility tables.

Best Practices

For Administrators

  • Monitor SignalR metrics – Track connection count, message throughput, latency
  • Set up Redis caching – Improves presence data lookup by 10×
  • Configure offline mode – Enable IndexedDB for remote and mobile workers
  • Plan for scale – Use Azure SignalR Service for >100 concurrent users
  • Review audit logs monthly – Detect unusual edit patterns or compliance issues

For Users

  • Watch for presence indicators – Check who's editing before making changes
  • Resolve conflicts promptly – Don't ignore conflict dialogs; data integrity depends on it
  • Use comments for coordination – @mention colleagues to clarify ownership or get approval
  • Save frequently – Auto-save every 30 seconds reduces conflict probability

For Developers

  • Use optimistic locking – Field-level RowVersion checks prevent lost updates
  • Handle conflicts gracefully – Show user-friendly conflict dialogs, not raw 409 errors
  • Test offline scenarios – Simulate network disconnects during integration testing
  • Cache presence data in Redis – Lookup must be <10ms for smooth UX

Next Steps

  1. Enable the feature – Contact Nodinite Sales for Mapify Premium licensing
  2. Review architecture – See Architecture and Presence for deployment requirements
  3. Plan scalability – Determine concurrent user count and choose SignalR tier
  4. Configure retention – Set change log retention per environment to meet compliance needs
  5. Train users – Share Comments and Annotations guide for collaborative annotation