Conflict state

Problem Context

• The product supports concurrent editing, offline editing, file sync, branch merging, record updates, draft publishing, import updates, or background sync.
• Two or more actors, devices, branches, jobs, or systems can change the same field, paragraph, file, record, or setting before one change is accepted.
• Automatic merge may be impossible or unsafe because changes overlap, carry business meaning, affect collaborators, or require human judgment.
• Local work, collaborator work, target branch changes, or server values must be preserved until a resolution decision is made.

Selection Rules

• Choose conflict state when two or more valid versions overlap and a choice, merge, save-copy, discard, or policy resolution is required.
• Show the conflict at the smallest understandable unit: field, sentence, paragraph, row, file, setting, branch hunk, or whole record.
• Label each side with source, owner, timestamp, device, branch, version, or system of record instead of ambiguous side names.
• Preserve both versions until resolution is committed, including local work that failed to upload or collaborator work that saved first.
• Offer resolution actions that match the data type: choose one side, combine text, accept or reject tracked changes, save a copy, keep both files, edit manually, or cancel.
• Show a preview or resolved value before committing when the conflict has business, legal, financial, medical, publication, code, or collaboration risk.
• Use sync state when the conflict is only a status inside a broader queue and no side-by-side resolution is required yet.
• Use draft state when the main task is managing an unpublished version rather than deciding between overlapping changes.
• Use error state when a save, load, or validation failed without another valid version to preserve or compare.
• Escalate to manual resolution when automatic or one-click resolution would hide context, discard data, or exceed product limits.

Required States

• No conflict state after automatic safe merge.
• Conflict detected state naming affected object and source versions.
• Side-by-side or inline comparison state for overlapping values.
• Choose mine or choose theirs state with preview.
• Manual merge state for combining text, structured values, or code.
• Save copy or keep both state when overwriting would lose work.
• Discard local change confirmation state.
• Resolved pending review state before commit when risk is high.
• Committed resolved state with audit trail or version history.
• Cannot resolve here state when the conflict requires another tool, permission, file type, or owner.

Interaction Contract

• Conflict detection stops silent overwrite and keeps every competing value recoverable.
• The surface states why automatic merge was not performed and what changed after the user started editing or syncing.
• Each resolution action states whose change is kept, whose change is removed, and whether the result will be saved, published, synced, or committed.
• Users can navigate between multiple conflicts, see progress through the list, and return to unresolved items.
• Manual merge preserves editing focus and shows unresolved markers until all required decisions are complete.
• Save copy or keep both keeps local data recoverable without claiming the conflict was resolved.
• After resolution, the product shows the final value, version, or commit before or immediately after the change is applied.
• Permission, file type, binary, branch protection, locked record, and policy limits route users to the correct manual or owner-assisted path.

Implementation Checklist

• Model conflict state separately from failed save, unsaved changes, draft, and sync progress.
• Store source values, base version, local version, remote version, actor, timestamp, device or branch, and resolution decision.
• Determine conflict granularity: field, block, row, document section, file, branch hunk, or full object.
• Provide comparison UI with stable labels, highlighted overlaps, untouched context, and enough surrounding content for judgment.
• Implement explicit actions for keep mine, keep theirs, merge manually, save copy, discard, accept, reject, cancel, and commit where relevant.
• Prevent duplicate submission or background overwrite while a conflict is unresolved.
• Record resolution audit information for collaborative, regulated, financial, code, or published content.
• Test simultaneous edits, offline return, stale browser tabs, autosave conflicts, binary file conflict copies, permission changes, bulk conflict resolution, undo limits, and screen reader navigation.

Common Generated-UI Mistakes

• Treating a conflict as a simple retryable save error.
• Letting newest timestamp win without preserving the losing value.
• Using ambiguous labels such as ours and theirs without explaining source and target.
• Showing a conflict count without the affected fields, values, owners, or timestamps.
• Resolving all conflicts with one default choice before users inspect discarded data.
• Hiding conflict copies or recovered edits in a separate location without linking them from the affected object.
• Merging structured or regulated data automatically when business meaning must be reviewed.

Critique Questions

• What are the competing versions, who created them, and when?
• What exact field, line, paragraph, file, or record overlaps?
• What value will survive after each action?
• Can users save or export their local work before discarding it?
• Can the conflict be safely merged automatically, or must a human review it?
• What audit trail, version history, or undo path remains after resolution?