Someone changed this record: showing an editing conflict
Preserve the work, compare versions and explain the next decision when edits conflict.
Article language: English

In this article
“Could not save. Try again.” The user tries as instructed. After the second click, her colleague's correction disappears and her older description of the building entrance returns. The message treated a conflict as a momentary network problem.
An editing conflict occurs when someone tries to save changes based on a state that another person or process has since changed. The interface should help them recognise the difference, preserve their work and choose a next step. The message must match how saving actually works. A warning drawn in a mockup cannot itself prevent an overwrite.
First preserve the work already done
Imagine a fictional service for the Open Place studio. Two people are editing a location description. Ewa corrects collection hours and Jan describes the courtyard entrance. Both started from the same version. Jan saves first. Ewa still sees the older form and presses “Save”. At that point the system should recognise the situation according to the agreed version-control mechanism.
A similar case can occur without a second person: Ewa opened the same location in two tabs and saved newer information in one. “Another user changed the record” would be misleading. The warning should describe the confirmed change of state and name an author only when the system actually identifies one.
Ewa needs answers to three questions: were her changes saved, whose work is currently in the system, and how can she finish? A red “Conflict” bar answers none of them. Nor does a single identical message for missing permission, a lost connection and an invalid time format.
After detecting a conflict, keep Ewa's entered text visible. Do not replace the form with a fresh read without warning: removing unsaved work creates a second problem. Agree whether her version remains in the form, a separate draft or a comparison view. Name the location and its durability according to the actual implementation.
Even “Refresh” needs a defined effect. Does it read the newer record while retaining her fields alongside it, or replace the entire form? If it discards unsaved text, say so before the action and provide the agreed way to preserve it. A button for resolving a conflict should not secretly discard work.
MDN's description of If-Match presents a conditional request mechanism in which the server compares the supplied ETag version identifier. If the condition fails, it returns 412 Precondition Failed. This is an example of a technical basis for save control, not an automatic feature of every form or a finished message design.
For a user, 412 is usually not the most useful information. A clearer description might be: “The location description changed since you opened the form. Your edits were not saved. Compare the versions.” Each sentence must match what the application has actually confirmed. Do not say “not saved” if the operation's outcome is unknown and needs checking.
Distinguish preserving a draft from saving the record. If the application holds working text only in the current tab, do not promise recovery after the browser closes. A form with saving and return (in Polish) needs its own durability rule. Here the editor should know what can safely be closed and where the correction can be resumed.
For a long form, identify the sections needing attention. Ewa should not have to reread the entire location description if the difference concerns only the entrance. Do not hide related fields, though. A changed entrance description may require checking directions or a language version; the presentation should support that judgement.
Three reference points in a comparison
Two columns, “Your version” and “Current version”, show a difference but do not always explain its origin. The state from which editing began can also help. Without it, Ewa sees different descriptions but cannot tell whether both people changed the same sentence or Jan corrected a passage she did not touch.
In our example, the initial state says collection is until 17:00 and entry is from the street. Ewa changes the time to 16:00; Jan changes the entrance to the courtyard. These are changes to different fields. The design can propose retaining both if the mechanism can combine them correctly. An attractive mockup alone does not make this an existing feature.
A second case is harder: both change collection time to different values. The difference between versions does not itself decide which is true. Someone who knows the location's arrangements must decide. The latest save time does not automatically make a value the correct one.
Changes to different fields may also be related. If one person disabled personal collection and another changed its hours, combining them requires understanding the whole record. Prepare that case alongside simple independent edits. A technical merge rule should not silently produce contradictory information for a visitor.
In the comparison show the field name, initial state, current state and the user's proposal. The initial view can focus on changed fields while providing access to full context. If the tool does not retain the initial state, describe the available comparison honestly. Do not reconstruct an old value from the user's memory as a certain historical fact.

After individual fields are resolved, show a coherent result for saving. A set of choices across several expanded panels is harder to assess than a complete location description. The user should be able to check that hours, entrance and additional notes form one understandable account. Only then does that state become the basis for the next save attempt.
Colour alone is not enough to mark a change in a long text. Add readable labels and allow both removed and added passages to be read. A keyboard or screen-reader user should be able to move through differences and choose a decision. Two narrow columns may need a different presentation on a phone while preserving the same information.
When comparing hours, show the day or period to which they apply. Two identical values may belong to different days of the week. In longer text, retain context around a changed passage so removal of a condition does not look cosmetic. A difference view should support understanding, not merely count changed characters.
MDN's guide to conditional requests describes the lost-update problem and leaves handling of the rejected change to the client application. Its options include notifying the user and showing differences. Detecting a conflict and helping resolve it are separate parts of the same process.
Do not turn a comparison into an automatic contest between authors. A name and time can establish context if the system provides them, but they do not establish correctness. Rather than a large “Jan changed your text”, show neutrally what changed and what decision remains.
If AI prepares the differences, comparing document versions (in Polish) needs a separate check of completeness and meaning. An omitted “not” can change the meaning of a decision even though the difference is small. The user should be able to inspect the original values from which the summary was made.
Name the effect of the next step
“Continue” could mean returning to your form, taking the newer version or overwriting the record. Such different actions should not share one vague label. Choose the paths the tool actually offers and name them for their effects.
“Return to your edits” keeps the work for further editing. “Use current version” discards your changes within the agreed scope. “Save combined changes” requires showing the combined result. Not every tool needs every option. The editor needs to understand the choice and control which edits are abandoned.
Overwrite permission requires a separate decision about access and process. If it exists, show its scope and consequence. Do not make it the only prominent button beside an inconspicuous exit. Someone trying to clear an error should not accidentally be given the quickest route to removing another person's work.
The record can change again after comparison. Ewa spends several minutes resolving a difference while someone adds a new collection instruction. Version checking must therefore cover the next save as well, according to the implemented mechanism. The design should anticipate another warning while preserving prepared resolutions where possible and agreed.
In the next comparison, identify the new change requiring attention. Do not present the entire old list as unresolved without saying why. An earlier choice may still apply; if new data changes its meaning, show that difference. The conditions belong to the agreed rule and should be tested.
The same issue arises when automation is the other party. Concurrent changes by AI and a person (in Polish) require identifying the version on which the work was based. The interface should present the result using the same rule, rather than treating the automated change as privileged truth.
Distinguish saving from publication too. Jan may have corrected a draft while visitors still see an older location description. Ewa needs to know whether she is comparing working content or the live view. The CMS publication process (in Polish) sets the later approval path; resolving a conflict need not complete it automatically.
Before release, prepare a test with two people or controlled sessions. First change different fields, then the same field, and finally save after another source change. Check preserved work, comparison and the final record read. Displaying a warning alone does not confirm that the right version was retained.
Add missing access and a deleted record to acceptance. These differ from a newer version of an existing description and may need different actions. Do not offer a comparison with “current content” if the application did not receive it. The user's edit should remain identifiable, but saving must respect the current state and permissions.
If a user cannot resolve the difference alone, show the agreed route for handing it to the responsible person. A preserved proposal needs a clear pending state, distinct from the approved description. On return, the editor must know whether a decision has been made and whether the working text still needs action. Do not leave that part of the workflow solely in an unrelated conversation.
Record the agreed rule in a design decision log (in Polish), with an example explaining it. A later panel change will then be less likely to reduce the entire process to “try again”. For a conversation with Aeneia Design, bring one such collision between edits. It provides a basis for designing the path from an unsaved form to a consciously agreed version.











