Free tools Windows power users keep installed
One-click scans. No signup required.
iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
If two writable database nodes accept conflicting updates before either has received the other’s change, both can report success while holding different data. What happens next depends on the replication design and conflict policy: the system may choose one value, preserve alternatives, merge operations, flag the conflict, or avoid the situation through coordination. An acknowledgement from each node alone does not mean the replicas agree.
How can both databases accept a write?
In an asynchronously replicated, multi-writer setup, separate nodes may accept writes locally without first asking every other node to approve or serialize them. Replication carries those changes to other nodes later. If two nodes change the same data before learning about each other’s updates, each can have a locally successful transaction and the replicas can temporarily diverge.
For example, two sales regions might read the same stock count. One records a sale at one node and another records a sale at a different node while the connection between them is delayed. Both writes may be acknowledged locally. The important question is not just which write arrived first, but what the database considers a conflict and whether its resolution preserves the business rule. Microsoft describes independent transactions and conflict detection in SQL Server peer-to-peer replication; Apache Cassandra describes replicas independently accepting mutations in its Dynamo architecture documentation.
What can the system do with conflicting updates?
There is no single outcome across databases. A product’s replication method, configured policy, data type, and application logic determine whether a conflict is detected and how it is resolved.
#1 Best Overall
| Approach | What happens to concurrent changes | Main consideration |
|---|---|---|
| Winner selection, such as last-write-wins | The system keeps one value according to an ordering rule, often timestamps. | A losing update may be discarded; the ordering may not match business intent. |
| Causality tracking or multi-value handling | Version metadata can help distinguish causally ordered changes from concurrent ones. Depending on the product policy, the system may select a value or make alternatives available for resolution. | The application may need logic to reconcile concurrent alternatives; not every product exposes them to users. |
| Operation-aware merge, including suitable CRDTs | Some operations can be combined so replicas converge without choosing one whole-record winner. | Only works when the data type’s merge rules preserve the application’s intended meaning. |
| Conflict detection or custom resolution | The system flags the conflict, applies configured resolver logic, or routes it for manual handling. | Requires a policy that protects the relevant business rules and a plan for unresolved cases. |
| Coordination before commit | A leader, quorum, or transaction protocol constrains which writes can commit and when. | Writes may depend on remote participants or a reachable leader, affecting availability and latency during failures. |
These are design patterns, not interchangeable guarantees. For product-specific examples, EDB Postgres Distributed’s conflict-resolution guidance covers conflict prevention and suitable CRDT use, while Azure Cosmos DB’s global distribution documentation describes causality tracking and configurable resolution policies.
Which update wins with last-write-wins?
“Last” commonly means latest according to a timestamp or another system ordering, not the latest human action or the most important business event. A timestamp-based policy can therefore keep a change that happened earlier in real life if clocks are skewed or timestamps do not represent the intended order.
Rank #2
Microsoft warns that clock skew can cause an objectively older update to win in its peer-to-peer replication guidance. Cassandra documents timestamp-based last-write-wins; timestamps can come from a client clock or, when a client timestamp is absent, the coordinator clock. Those product details should not be generalized to every database or deployment. Check the exact product version and configuration before relying on timestamp ordering.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsCan a merge preserve both changes?
Sometimes. If concurrent changes affect independent fields, an application or database may be able to retain both. For operations such as incrementing a counter, a CRDT-style data type may merge updates according to rules designed for that operation. Redis Cloud’s Active-Active application guidance describes CRDT-based handling, and EDB’s conflict-resolution documentation recommends CRDT types for suitable concurrent updates.
A merge is safe only if its semantics fit the application. Combining increments may be meaningful; blindly combining two edits to a shipping address or two reservations for the last available item may not be. A system that converges technically can still violate a business invariant unless the data model or resolver enforces it.
How can a system reduce the chance of conflicting commits?
Coordination reduces the freedom for isolated nodes to accept competing writes. Applications can route a record’s writes through one leader, require quorum participation, or use a distributed transaction protocol. These choices constrain commits but may add latency, communication overhead, or dependence on remote nodes being reachable. Redis documents availability and network tradeoffs for two-phase commit and geo-distributed quorum writes in its Active-Active guidance; EDB describes leader routing and quorum commit options in its conflict management documentation.
Rank #4
Before choosing a policy, answer these design questions:
- Must a node accept writes when it cannot reach its peers?
- Does a successful acknowledgement mean local acceptance, quorum agreement, or globally coordinated commit?
- Should concurrent changes be retained as alternatives, merged, reduced to one winner, or flagged for resolution?
- Which business invariants must never be broken, such as inventory staying at or above zero?
- What latency, availability, clock, version-metadata, custom-code, or operator costs can the application tolerate?
What should you check for a specific database?
These examples illustrate different product behaviors, not a universal database rule. The cited SQL Server page is for SQL Server 17 documentation and notes that its last-writer-wins capability begins with SQL Server 2019 CU 13. Cassandra’s linked guide is the current “latest” documentation and may change across versions. Redis guidance cited here applies to Redis Cloud Active-Active; Cosmos DB and EDB describe their own protocols and configurable policies. For an implementation decision, verify the documentation and settings for the exact product, version, and deployment rather than assuming a policy from another system applies.
Quick Recap
Best Value
- Used Book in Good Condition
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
