Cloud concept · Updated

Strong Consistency - Strong consistency guarantees that a successful read reflects the latest completed write within the system’s defined consistency scope.

In short

Strong consistency lets applications read current data after a write succeeds, rather than temporarily receiving an older value from a lagging replica. It matters when stale information could cause incorrect decisions, but it does not replace transactions, conditional updates, or concurrency control.

Cloud Concepts Hub →

6 key aspects of Strong Consistency

Strong consistency provides current reads within a defined scope, while leaving concurrency control, transaction boundaries, and end-to-end freshness as separate design responsibilities.

01
Visibility of completed writes

A read started after a successful write must reflect that write or a later one within the supported consistency scope. Applications can verify updates without waiting for replica convergence.

02
Real-time operation ordering

Under linearizability, operations behave as though they occur one at a time in an order that respects completed operations. Reads overlapping a write can legitimately observe either side of that write.

03
Explicit consistency boundaries

Guarantees can differ across tables, indexes, endpoints, and Regions. Check the exact read operation and replication configuration instead of assuming that every access path is strongly consistent.

04
Coordination and availability trade-offs

Maintaining current reads can require coordination that increases latency or cost. During a network partition, preserving strong consistency can require rejecting or delaying requests.

05
Separate concurrency controls

Fresh reads alone do not prevent competing writers from making conflicting updates. Use conditional writes, version checks, or transactions to protect application invariants.

06
End-to-end read-path correctness

An application can still return stale data if it reads from an outdated cache or asynchronously maintained projection. Route correctness-sensitive reads through an access path that preserves the required guarantee.

Cloud services for Strong Consistency

A cloud application can use DynamoDB for current operational records and S3 for immediately readable objects, while still treating updates across those services as separate operations. A successful S3 upload does not atomically commit an associated DynamoDB record, and strong reads do not remove that coordination problem. Spanner illustrates a database alternative that combines strong reads with distributed transactions within its supported boundaries. Across these designs, applications must select the appropriate read mode, account for caches and replication paths, and use conditional updates or transactions when correctness requires more than fresh data.

Amazon DynamoDBAmazon DynamoDB

DynamoDB supports strongly consistent reads on tables and local secondary indexes when supported read requests specify ConsistentRead=true; global secondary indexes support only eventual consistency. Strong reads consume twice the read capacity of eventual reads for the same item size, and cross-Region guarantees depend on the global table consistency mode.

Amazon S3Amazon S3

Amazon S3 provides strong read-after-write consistency for object writes, overwrites, and deletes, including subsequent object reads and listing operations. This does not provide atomic transactions across multiple object keys or eliminate propagation delays in separate cross-Region replication workflows.

Strong Consistency exam questions

Real practice exam questions on Strong Consistency, with the correct answer and its explanation. Answer them with every option in the exam simulator.

DVA-C02

A pricing application stores each product's price and an increasing version number in the same row in Amazon RDS for MySQL. Each price update atomically changes the price and increments the version. After the transaction commits, the application sends the product ID and committed version to a document-generation worker.

The worker must read from an asynchronous read replica to avoid adding read load to the primary. It must use the price from the specified version or a later version, never an older version. If suitable data is not available within 10 seconds, the worker can defer processing. Products are not deleted, and each worker query runs in a new autocommit transaction.

Which implementation meets these requirements?

Show answerCORRECT ANSWER

Retrieve the price and version together from the replica. Use the price only if the returned version is at least the version in the message; otherwise, retry until the 10-second deadline and then defer processing.

The version check verifies the freshness of the actual data returned. Because the price and version change atomically in the same row, an acceptable version identifies an acceptable price. New autocommit transactions allow retries to observe newly replicated changes. Deferring at the deadline avoids returning stale data when replication takes longer than expected.

SAP-C03

A financial services company is migrating a PostgreSQL application to AWS. The application uses PostgreSQL stored procedures and multi-table ACID transactions that must remain unchanged. Most database activity consists of read-only customer-history queries that can tolerate replication lag. However, after a payment transaction commits, any application instance that retrieves the payment status must immediately see the committed result. These status queries start new database transactions.

Load testing shows that one appropriately sized database instance can handle all writes and payment-status queries, but cannot also handle the customer-history queries. The database must automatically recover from an Availability Zone failure without losing acknowledged transactions. The company wants to minimize ongoing database administration.

Which solution meets these requirements?

Show answerCORRECT ANSWER

Deploy Amazon RDS for PostgreSQL as a Multi-AZ DB instance deployment. Create read replicas for customer-history queries. Route writes and payment-status queries to the primary DB instance endpoint, and route customer-history queries to the read replica endpoints.

The Multi-AZ DB instance deployment provides synchronous standby replication and managed automatic failover for Availability Zone failures. Separate, asynchronously replicated read replicas offload customer-history queries. Directing new payment-status transactions to the primary avoids stale results caused by replica lag. RDS also manages routine database administration while preserving PostgreSQL functionality.

Practice Strong Consistency in a full exam

Questions on Strong Consistency in each practice exam, with every answer option and an explanation for each:

Start a free practice exam

What is Strong Consistency

3 min read

Strong consistency describes a data-access guarantee: once a write completes successfully, a subsequent read within the covered scope must reflect that write or a later write. In distributed systems, this is commonly expressed as linearizability: operations appear to occur atomically in a single order that respects their real-time completion. If a read overlaps a write, either the previous value or the new value may be valid, depending on where the operations fall in that order.

For example, an application changes an account’s notification preference and receives a successful response. A strongly consistent read started afterward must not return the preference that existed before that update, unless another write has restored it. This guarantee applies to other clients too; it is stronger than merely allowing the writing client to read its own changes.

Eventually consistent reads can temporarily return older data while replicas catch up. If updates stop and replication continues successfully, the replicas eventually converge. Eventual consistency can be appropriate for activity feeds or noncritical dashboards, whereas strong consistency is useful when a workflow must immediately verify a completed update. The choice should follow the application’s correctness requirements rather than a blanket preference for one model.

Cloud databases implement these guarantees through mechanisms such as leader coordination, replication protocols, and quorum-based decisions. The guarantee belongs to a documented operation and scope, not automatically to every endpoint, index, cache, or Region associated with the service. A strongly consistent database read cannot make an application cache current. Similarly, an asynchronously updated search index can remain stale even when its source database supports strong reads.

Amazon DynamoDB illustrates an explicit read-consistency choice. Reads are eventually consistent by default; supported operations can request strong consistency with ConsistentRead set to true. Tables and local secondary indexes support strongly consistent reads, but global secondary indexes do not. For the same item size, a strongly consistent read consumes twice the read capacity of an eventually consistent read. Cross-Region expectations must also match the configured global table consistency mode rather than being inferred from a local read setting.

Strong consistency does not prevent read-modify-write races. Two checkout workers can both read that one unit remains and both attempt to sell it. A conditional update that decrements stock only when sufficient inventory remains prevents this race; a transaction may be needed when several records must change together. Likewise, individually strong reads across a scan do not necessarily provide a single point-in-time snapshot of the entire dataset. Database consistency should not be confused with the consistency property of ACID, which concerns preserving application invariants.

The trade-offs include coordination overhead, potentially higher latency, and sometimes higher request cost. During a network partition, a system preserving linearizability cannot also guarantee successful operations on every disconnected side; it may reject or delay requests rather than serve stale data. Strong consistency also does not mean zero latency, synchronous replication to every replica, or automatic atomicity across multiple objects. In exam scenarios, identify whether immediate visibility is required, whether the selected access path supports it, and whether the real requirement also needs conditional writes or transactions.

Learn Strong Consistency in lessons

2 short lessons on Strong Consistency in 1 certification course.

Open the lessons