# cache-invalidation

Published articles for cache-invalidation.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Cache invalidation is a distributed systems problem

DevFeed: [Cache invalidation is a distributed systems problem](<https://devfeed.tech/articles/cache-invalidation-is-a-distributed-systems-problem-in-a-convenience-costume-39604.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/52-cache-invalidation-distributed-problem/>)

Author: hello@ankit-rana.com

Published: 2026-09-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [race-conditions](<https://devfeed.tech/tags/race-conditions.md>), [redis](<https://devfeed.tech/tags/redis.md>), [ttl](<https://devfeed.tech/tags/ttl.md>)

### AI overview

Cache invalidation coordinates updates between a database and a cache without a shared transaction. The article explains how operation ordering can let a concurrent reader repopulate stale data and recommends writing to the database before invalidating the cache, followed by a second invalidation to close the remaining race.

### Source excerpt

A cache and a database are two stores that must agree, which makes every invalidation a distributed transaction without a coordinator. The ordering matters more than the mechanism: invalidating before the database write leaves a window where a concurrent reader repopulates the cache with the old value and it stays wrong until the TTL expires. Deleting the key rather than writing the new value removes a whole class of ordering bug, because two concurrent deletes commute and two concurrent writes do not.

## Why CRUD APIs Stop Teaching New Lessons After Basic Production Problems Are Solved

DevFeed: [Why CRUD APIs Stop Teaching New Lessons After Basic Production Problems Are Solved](<https://devfeed.tech/articles/boredom-is-a-signal-to-find-a-harder-problem-when-your-crud-api-stops-teaching-you-39585.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/33-game-of-life-boredom-harder-problem/>)

Author: hello@ankit-rana.com

Published: 2026-08-02T00:00:00Z

Content type: opinion

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [CRUD](<https://devfeed.tech/topics/crud.md>), [REST API](<https://devfeed.tech/topics/rest-api.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Network](<https://devfeed.tech/topics/network.md>), [Redis](<https://devfeed.tech/topics/redis.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [backend](<https://devfeed.tech/tags/backend.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [career](<https://devfeed.tech/tags/career.md>), [crud](<https://devfeed.tech/tags/crud.md>), [latency](<https://devfeed.tech/tags/latency.md>), [learning](<https://devfeed.tech/tags/learning.md>), [network](<https://devfeed.tech/tags/network.md>), [schema](<https://devfeed.tech/tags/schema.md>), [schema-design](<https://devfeed.tech/tags/schema-design.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

A small CRUD API teaches backend fundamentals such as validation, schema design, migrations, query behavior, connection pooling, and cache invalidation. After those issues are understood, developers may need more complex failure domains involving cross-service contracts, event ordering, and slow downstream calls to continue learning.

### Source excerpt

A todo CRUD API teaches real things, including validation, schema design, the N+1 query, index selection, pool sizing, and cache invalidation, and then it goes quiet. Boredom arriving right after you fix those once is not laziness; it is the signal that the problem stopped presenting decisions you have not already seen. The move is up the stack, to a failure domain with cross-service contracts, event ordering, and downstream calls that hang.

## Keycloak Client Libraries 26.0.8 released

DevFeed: [Keycloak Client Libraries 26.0.8 released](<https://devfeed.tech/articles/keycloak-client-libraries-26-0-8-released-31749.md>)

Original publisher: [Read original article](<https://www.keycloak.org/2026/01/keycloak-client-2608-released>)

Author: Keycloak Team

Published: 2026-01-09T00:00:00Z

Content type: release

Language: en

Sources: [Keycloak Blog](<https://devfeed.tech/sources/keycloak-blog.md>)

Topics: [Keycloak](<https://devfeed.tech/topics/keycloak.md>), [client](<https://devfeed.tech/topics/client.md>), [servers](<https://devfeed.tech/topics/servers.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [client](<https://devfeed.tech/tags/client.md>), [idm](<https://devfeed.tech/tags/idm.md>), [kerberos](<https://devfeed.tech/tags/kerberos.md>), [keycloak](<https://devfeed.tech/tags/keycloak.md>), [keycloak-client-libraries-release](<https://devfeed.tech/tags/keycloak-client-libraries-release.md>), [ldap](<https://devfeed.tech/tags/ldap.md>), [migration-guide](<https://devfeed.tech/tags/migration-guide.md>), [openid-connect](<https://devfeed.tech/tags/openid-connect.md>), [release](<https://devfeed.tech/tags/release.md>), [saml](<https://devfeed.tech/tags/saml.md>), [server](<https://devfeed.tech/tags/server.md>), [sso](<https://devfeed.tech/tags/sso.md>)

### AI overview

Keycloak Client Libraries 26.0.8 was released on January 9, 2026. The release includes synchronization with the Keycloak server 26.5.0 release and resolves a policy enforcer request behavior issue after cache invalidation.

### Source excerpt

Upgrading Before upgrading refer to the migration guide for a complete list of changes. All resolved issues Enhancements #193 Sync keycloak-client after Keycloak server 26.5.0 release client Bugs #190 The policy enforcer rejects the request the first time, but after the cache invalidation interval, it allows it. client

## Scaling Nextdoor's Datastores: Part 5

DevFeed: [Scaling Nextdoor's Datastores: Part 5](<https://devfeed.tech/articles/scaling-nextdoor-s-datastores-part-5-20344.md>)

Original publisher: [Read original article](<https://engblog.nextdoor.com/scaling-nextdoors-datastores-part-5-5221da60f374?source=rss----5e54f11cdfdf---4>)

Author: Slava Markeyev

Published: 2025-03-19T15:09:15Z

Content type: article

Language: en

Sources: [Nextdoor](<https://devfeed.tech/sources/nextdoor.md>)

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Usability](<https://devfeed.tech/topics/usability.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching-strategies](<https://devfeed.tech/tags/caching-strategies.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database-consistency](<https://devfeed.tech/tags/database-consistency.md>), [database-scalability](<https://devfeed.tech/tags/database-scalability.md>), [databases](<https://devfeed.tech/tags/databases.md>), [rdbms](<https://devfeed.tech/tags/rdbms.md>), [reconciliation](<https://devfeed.tech/tags/reconciliation.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [stream](<https://devfeed.tech/tags/stream.md>), [usability](<https://devfeed.tech/tags/usability.md>)

### AI overview

The final installment of Nextdoor's datastore-scaling series explains how cache consistency can fail when a database writer misses its cache update. It presents a Change Data Capture stream and a reconciler that uses database changes to repair cache inconsistencies.

### Source excerpt

In this final installment of the Scaling Nextdoor's Datastores blog series, we detail how the Core-Services team at Nextdoor solved cache consistency challenges as part of a holistic approach to improve our database and cache scalability and usability. In Part 4: Keeping the cache consistent, we highlighted a class of consistency issues arising from racing cache writes and introduced an approach for forward cache versioning as a mechanism to avoid inconsistencies. The cache is able to decide which write to persist and which to reject because it is aware of the version of data it currently has. However, this is only a partial solution because it assumes writers will always succeed in communicating with the cache in a timely manner, if at all. Missed Writes Let's consider the scenario where Writers A and B both performed an update to the same row in the database and have not yet updated the cache. Writer A holds Version 1 and Writer B holds Version 2. What happens if Writer B with Value 2 fails to talk with the cache? Writer B fails to write to the cache. In this case the result is that the cache becomes inconsistent and we can't rely on the writers to provide that consistency. A process must exist outside of this interaction to fix-up the cache when Version 2 is written to the database but fails to be written to the cache. Change Data Stream To solve this problem we tap into a common feature provided by most modern databases, a Change Data Capture (CDC) Stream. A CDC Stream is a mechanism to subscribe to row level changes in a database. The change stream contains a row's previous column values along with the new values. Here's a visual example of the change stream when the last_name field gets updated in the database. For visual clarity the changed values have been underlined in red. Reconciler Since the database is the source of truth and the CDC Stream emits all changes, a consumer of this stream can clean up any consistency issues in the cache. In our system we ca

## Scaling Nextdoor's Datastores: Part 4

DevFeed: [Scaling Nextdoor's Datastores: Part 4](<https://devfeed.tech/articles/scaling-nextdoor-s-datastores-part-4-20343.md>)

Original publisher: [Read original article](<https://engblog.nextdoor.com/scaling-nextdoors-datastores-part-4-c9d3d3edcd34?source=rss----5e54f11cdfdf---4>)

Author: Ronak Shah

Published: 2025-03-19T15:08:57Z

Content type: article

Language: en

Sources: [Nextdoor](<https://devfeed.tech/sources/nextdoor.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cache-control](<https://devfeed.tech/tags/cache-control.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [database-consistency](<https://devfeed.tech/tags/database-consistency.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [examples](<https://devfeed.tech/tags/examples.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [lua](<https://devfeed.tech/tags/lua.md>)

### AI overview

Part 4 of Nextdoor's datastore series explains how racing database writes can update a cache in a different order, allowing stale writes and leaving the cache inconsistent with the database. It introduces the problem and notes that the full solution will be covered in a later installment.

### Source excerpt

In this part of the Scaling Nextdoor's Datastores blog series, we will see how the Core-Services team at Nextdoor keeps its cache consistent with database updates and avoids stale writes to the cache. In this post, we'll focus specifically on inconsistencies caused by racing writes and our solution. We'll discuss other causes and our full solution for consistent caching in the next installment of our blog: Part 5: A time-bounded eventually-consistent cache. Inconsistent Cache Caches can become inconsistent with the database for several reasons, such as: Racing Writes / Concurrent Updates: Multiple writes occurring simultaneously can result in a stale cache. Missed Writes / Failing to Update the Cache: Failure to update or set cache correctly after a database write. Delayed Cache Updates or Deletes: Slow propagation of updates or invalidation can leave the cache out of sync. Application-Level Bugs: Bugs in application side caching logic. Maintaining cache consistency with the database is crucial for data accuracy, especially in distributed systems with concurrent web requests. Consistent caching ensures reliable read-after-write behavior, improving performance and user experience. Without it, applications may face unpredictable behavior and user frustration. A well-designed caching system boosts performance, ensures consistency, and delivers up-to-date data even under high concurrency. Racing Writes Let's look at the scenario where two writers, A and B, update the same user in the database but write to the cache in a different order, causing the cache to become inconsistent with the database. Author's Note: In examples moving forward we'll use "User_1" to mean id=1 in the "users" table.Look-Aside Cache with two writers. Sequence of operations: Writer A updates the name of user_1 to Foo in the database. Writer B updates the name of the same user_1 to Bar in the database. Writer B updates the cache for user_1 with name = Bar. Writer A updates the cache for user_1 with

## Scaling Nextdoor's Datastores: Part 3

DevFeed: [Scaling Nextdoor's Datastores: Part 3](<https://devfeed.tech/articles/scaling-nextdoor-s-datastores-part-3-20342.md>)

Original publisher: [Read original article](<https://engblog.nextdoor.com/scaling-nextdoors-datastores-part-3-e9b4dd8a9393?source=rss----5e54f11cdfdf---4>)

Author: Ronak Shah

Published: 2025-03-19T15:08:43Z

Content type: article

Language: en

Sources: [Nextdoor](<https://devfeed.tech/sources/nextdoor.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [schema-evolution](<https://devfeed.tech/topics/schema-evolution.md>), [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Django](<https://devfeed.tech/topics/django.md>), [Python](<https://devfeed.tech/topics/python.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [valkey](<https://devfeed.tech/topics/valkey.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [database](<https://devfeed.tech/tags/database.md>), [django](<https://devfeed.tech/tags/django.md>), [lua](<https://devfeed.tech/tags/lua.md>), [python](<https://devfeed.tech/tags/python.md>), [redis](<https://devfeed.tech/tags/redis.md>), [schema](<https://devfeed.tech/tags/schema.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>), [thundering-herd](<https://devfeed.tech/tags/thundering-herd.md>), [valkey](<https://devfeed.tech/tags/valkey.md>)

### AI overview

Part 3 of Nextdoor's datastore-scaling series explains how applications serialize database objects for Redis or Valkey look-aside caches. It describes compatibility problems caused by runtime, package, and schema changes, including cache misses and thundering-herd effects during migrations.

### Source excerpt

In this part of the Scaling Nextdoor's Datastores blog series, we'll explore how the Core-Services team at Nextdoor serializes database data for caching while ensuring forward and backward compatibility between the cache and application code. In part 1 of this series we discussed how ORMs, object-relational mapping frameworks, help abstract away database specific schemas and queries from application code. Developers simply utilize objects in their application's language to access database data. Here's a simple example of using Python's Django ORM to define a model: from django.db import models class Users(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) The associated SQL create table would look like: CREATE TABLE users ( "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, "first_name" varchar(30) NOT NULL, "last_name" varchar(30) NOT NULL ); Developers would then access database data like this: user_id = 123 user = User.objects.get(id=user_id) print(user.first_name)Object Byte Serialization for Caching An issue arises when adding a look-aside cache such as Redis/Valkey to an application: How do you store what you got from the database in the cache? A common solution to caching complex objects, such as those from ORMs, is object byte serialization. This process converts language objects into bytes before storing them in the cache. When reading from the cache the process is done in reverse where the byte data is turned into language objects. For instance in Python this is often done with the pickle package. The interaction between the application, database, and the cache looks like this: Look-Aside Cacheimport pickle # Try getting from cache ('None' if not in cache) user_bytes = cache.get("user_123") if user_bytes is not None: # Read bytes using pickle user = pickle.loads(user_bytes) else: # Fetch from database user = User.objects.get(id=123) # Convert to bytes user_bytes = pickle.dumps(user) # Sto

## How DatoCMS solved tag invalidation with Turso

DevFeed: [How DatoCMS solved tag invalidation with Turso](<https://devfeed.tech/articles/how-datocms-solved-tag-invalidation-with-turso-5957.md>)

Original publisher: [Read original article](<https://turso.tech/blog/how-datocms-solved-tag-invalidation-with-turso>)

Author: Alessio Pinto

Published: 2024-07-15T00:00:00Z

Content type: article

Language: en

Sources: [Turso Blog](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [Turso](<https://devfeed.tech/topics/turso.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Next.js](<https://devfeed.tech/topics/next-js.md>), [GraphQL](<https://devfeed.tech/topics/graphql.md>), [API](<https://devfeed.tech/topics/api.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [code](<https://devfeed.tech/tags/code.md>), [content](<https://devfeed.tech/tags/content.md>), [database](<https://devfeed.tech/tags/database.md>), [developer](<https://devfeed.tech/tags/developer.md>), [digital-experiences](<https://devfeed.tech/tags/digital-experiences.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [next-js](<https://devfeed.tech/tags/next-js.md>), [performance](<https://devfeed.tech/tags/performance.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [turso](<https://devfeed.tech/tags/turso.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

DatoCMS uses Turso to store cache tag mappings and work around Next.js's 64-tag-per-cache-item limit. This enables instant, targeted page regeneration when content changes.

### Source excerpt

How DatoCMS uses Turso to store cache tag mappings and solve Next.js's 64 tag per item limit, enabling instant, surgical page regeneration on content change.

## Improvements in the Build Configuration Input Tracking

DevFeed: [Improvements in the Build Configuration Input Tracking](<https://devfeed.tech/articles/improvements-in-the-build-configuration-input-tracking-24646.md>)

Original publisher: [Read original article](<https://blog.gradle.org/improvements-in-the-build-configuration-input-tracking>)

Author: Mikhail Lopatkin

Published: 2023-09-01T04:00:00Z

Content type: article

Language: en

Sources: [The Gradle Blog](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [configuration](<https://devfeed.tech/topics/configuration.md>)

Tags: [build-performance](<https://devfeed.tech/tags/build-performance.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [environment-variables](<https://devfeed.tech/tags/environment-variables.md>), [files](<https://devfeed.tech/tags/files.md>), [gradle](<https://devfeed.tech/tags/gradle.md>)

### AI overview

This article explains improvements in Gradle's build configuration input tracking. It describes how the configuration cache fingerprints build scripts, dependencies, environment values, files, filesystem information, and external-process output, then rechecks those inputs to determine whether cached configuration results can be reused safely.

### Source excerpt

The configuration cache is a feature that significantly improves build performance by caching the result of the configuration phase and reusing it for subsequent builds. Using the configuration cache, the Gradle Build Tool can skip the configuration phase entirely when nothing that affects the build configuration, such as build scripts, has changed. In Gradle 8.1, the configuration cache became stable and recommended for adoption. Stability, in this case, means that the behavior is finalized, and all breaking changes follow the Gradle deprecation process. In general, if something works now, it will continue to work the same way--unless the behavior is buggy and may lead to incorrect builds. While some features are not yet implemented, most users can already benefit from the speed-ups brought by the configuration cache. Build configuration inputs When writing configuration-cache-compatible build logic or plugins, it is important to understand what Gradle considers build configuration inputs and how they affect cache invalidation. The concept is similar to task caching: Everything that contributes to the build logic execution is an input. The configuration phase is an action. The resulting task execution graph is the output. Examples of the build configuration inputs are: Build scripts and their dependencies (plugins and libraries). Environment variables and system properties read at configuration time. Files read by the build logic or plugins at configuration time. Information about the file system (existence of files, directory structure) obtained at configuration time. The output of external processes executed at configuration time. When build logic or a plugin reaches out to something "environmental" at configuration time, the obtained data becomes part of the configuration cache fingerprint. Next time the build runs, Gradle checks if the values of the inputs are still the same--it re-reads environment variables, system properties, files, and re-runs external proces

## Varnish to Redis Migration

DevFeed: [Varnish to Redis Migration](<https://devfeed.tech/articles/varnish-to-redis-migration-26226.md>)

Original publisher: [Read original article](<https://medium.com/groupon-eng/varnish-to-redis-migration-887ad6d805d2?source=rss----5c13a88f9872---4>)

Author: Ravikumar

Published: 2022-03-22T15:39:20Z

Content type: article

Language: en

Sources: [Groupon Engineering -- Medium](<https://devfeed.tech/sources/groupon-engineering-medium.md>)

Topics: [migration](<https://devfeed.tech/topics/migration.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Amazon EKS](<https://devfeed.tech/topics/amazon-eks.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [distributed-transaction](<https://devfeed.tech/tags/distributed-transaction.md>), [haproxy](<https://devfeed.tech/tags/haproxy.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [migration](<https://devfeed.tech/tags/migration.md>), [nginx](<https://devfeed.tech/tags/nginx.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [redis](<https://devfeed.tech/tags/redis.md>), [varnish](<https://devfeed.tech/tags/varnish.md>)

### AI overview

Groupon describes migrating its Varnish caching infrastructure to Redis while moving application workloads to AWS EKS. The article focuses on a high-traffic place read service, the limitations of TTL-based cache invalidation, and the planned shift to event-based expiration.

### Source excerpt

At Groupon, we are in the process of migrating our app workloads to AWS EKS. As part of the migration, we are also in the process of re-architecting our services to make them cloud & Kubernetes optimised. In this article, we will focus on the impact of cloud migration on Varnish caching at Groupon. For the uninitiated, Varnish is a high-performance reverse caching proxy. For simplicity, you can think of it as a general proxy such as HAProxy or Nginx with caching support so that it doesn't have to go to a backend service every time it receives a request. Internally, Varnish cache uses pthreads heavily(to the tune of 1000s) to serve the requests. In contrast, Redis is single-threaded. Varnish at Groupon & Place Read Service We have been using Varnish for many of our high-traffic services. These read-heavy services get traffic to the tune of millions of RPM. One such service is our place read service which is called on each & every deal page visit; it will be the focus of this article. Place read service stores all the locations a deal can be redeemed. Ex: Redemption location details of the deal https://www.groupon.com/deals/parent-big-littles-3 is highlighted below. Traffic pattern of place read service The service is called more than a billion times a day with peak traffic of ~2 million requests per minute. Current architecture (simplified) The traffic is served by a cluster of 4 Varnish servers (40GB RAM). The current Varnish hit rate is 95%. This is admittedly a low hit rate for a read-heavy service, the main reason being our TTL-based cache invalidation logic. Varnish cache invalidation We are using TTL-based cache invalidation. This usually leads to a problem where Varnish starts bombarding the backend service when most of the keys expire at the same time. Request coalescing is not very helpful when the unique keys count is in millions (which is the case with our service). As a workaround, we use randomised TTLs (between 30 to 60 mins) so that all the keys don't

## Debezium and Friends - Conference Talks 2021

DevFeed: [Debezium and Friends - Conference Talks 2021](<https://devfeed.tech/articles/debezium-and-friends-conference-talks-2021-18810.md>)

Original publisher: [Read original article](<https://www.morling.dev/blog/debezium-talks-2021/>)

Published: 2021-11-02T09:50:00Z

Content type: article

Language: en

Sources: [Gunnar Morling](<https://devfeed.tech/sources/gunnar-morling.md>)

Topics: [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Kafka](<https://devfeed.tech/topics/kafka.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [MongoDB](<https://devfeed.tech/topics/mongodb.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [conference](<https://devfeed.tech/tags/conference.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [quarkus](<https://devfeed.tech/tags/quarkus.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [talks](<https://devfeed.tech/tags/talks.md>)

### AI overview

A 2021 recap of four conference talks about Debezium and change data capture. The talks cover CDC usage patterns, data engineering with open-source projects, distributed caching, Apache Kafka, real-time order delivery analysis, and legacy-system modernization.

### Source excerpt

Table of Contents Don't Fear Outdated Caches - Change Data Capture to the Rescue! Change Data Streaming Patterns in Distributed Systems Analyzing Real-time Order Deliveries using CDC with Debezium and Pinot Dissecting our Legacy: The Strangler Fig Pattern with Apache Kafka, Debezium and MongoDB Bonus: Debezium at the Trino Community Broadcast Learning More If you love to attend conferences around the world without actually leaving the comfort of your house, 2021 certainly was (and is!

## Working with Apollo Client Cache: Cache Keys, Invalidation, and Fetch Policies

DevFeed: [Working with Apollo Client Cache: Cache Keys, Invalidation, and Fetch Policies](<https://devfeed.tech/articles/tips-and-tricks-for-working-with-apollo-cache-19125.md>)

Original publisher: [Read original article](<https://medium.com/rbi-tech/tips-and-tricks-for-working-with-apollo-cache-3b5a757f10a0?source=rss----904782439303---4>)

Author: Tommy Suwunrut

Published: 2020-10-29T19:16:34Z

Content type: tutorial

Language: en

Sources: [RBI Tech](<https://devfeed.tech/sources/rbi-tech.md>)

Topics: [apollo-client](<https://devfeed.tech/topics/apollo-client.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [GraphQL](<https://devfeed.tech/topics/graphql.md>), [Front end](<https://devfeed.tech/topics/frontend.md>)

Tags: [apollo](<https://devfeed.tech/tags/apollo.md>), [apollo-client](<https://devfeed.tech/tags/apollo-client.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [fetch](<https://devfeed.tech/tags/fetch.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [programming](<https://devfeed.tech/tags/programming.md>), [react](<https://devfeed.tech/tags/react.md>)

### AI overview

This tutorial explains how Apollo Client normalizes and stores GraphQL query results, including cache keys based on object properties and schema types. It discusses why collection queries may remain stale after server-side updates and introduces fetch policies as one way to manage cache behavior.

### Source excerpt

Photo by Stephen Walker on Unsplash With its declarative fetching, helpful tooling, extensive type definitions, and built-in integration with React, Apollo Client has played a fundamental role in simplifying frontend architecture over the past few years. Its built-in caching layer, which allows you to retrieve previously requested data without needing to make additional network requests to the server, has the potential to make any application feel snappier. Apollo even provides ways of warming up the cache to be used for later, freeing our frontends from the dreaded loading spinners. But cache invalidation is one of those notoriously difficult problems in any computer program, and trying to update or bust Apollo's cache after server-side updates is far from a perfect experience, especially when the queries being cached have many filters and constraints. Let's begin with an overview of how Apollo's cache works, and then discuss the tradeoffs involved with a few different approaches to working with it. Throughout this article we'll be using this Mock List application as a reference. Cache Keys When you make any graphQL query, by default Apollo caches the response in what it calls a flat, normalized lookup table. It constructs a unique identifier for each object returned from your query, by combining its id or _id properties with the __typename defined in your schema. So if the application above executes queries as the user types "G", then "Go", then "Go g", all the way to "Go groceries shopping", Apollo could potentially pull down information about many different tasks and cache each one roughly like this: Task:1234: { name: "Go grocery shopping" } Task:2345: { name: "Go to gym" } Task:3456: { name: "Learn GoLang" } This is great if the user navigates to a detail view about a given task, because there will already be some data immediately available. Apollo will also store the results of each of those individual queries, in case you make the same exact query again late

## First Impressions with Apollo Client 3

DevFeed: [First Impressions with Apollo Client 3](<https://devfeed.tech/articles/first-impressions-with-apollo-client-3-23305.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/first-impressions-with-apollo-client-3>)

Author: Sean Dearnaley

Published: 2020-03-13T04:48:00Z

Content type: article

Language: en

Sources: [Apollo Blog](<https://devfeed.tech/sources/apollo-blog.md>)

Topics: [apollo-client](<https://devfeed.tech/topics/apollo-client.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [apollo-client](<https://devfeed.tech/tags/apollo-client.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [community](<https://devfeed.tech/tags/community.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [release](<https://devfeed.tech/tags/release.md>)

### AI overview

A first-person review of the Apollo Client 3 beta, focusing on cache improvements such as invalidation, garbage collection, eviction, immutable cache results, and declarative type and field policies.

### Source excerpt

I've been using the Apollo platform for almost two years now. I've used it on several commercial applications, and it's become one of my all-time favorite frameworks. With the upcoming release of Apollo Client 3, I thought it would be an excellent time to test out the latest beta and write about some of the exciting improvements I'm most excited about.

## Previewing the Apollo Client 3 Cache

DevFeed: [Previewing the Apollo Client 3 Cache](<https://devfeed.tech/articles/previewing-the-apollo-client-3-cache-23485.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/previewing-the-apollo-client-3-cache-565fadd6a01e>)

Author: Hugh Willson

Published: 2019-10-28T18:36:00Z

Content type: release

Language: en

Sources: [Apollo Blog](<https://devfeed.tech/sources/apollo-blog.md>)

Topics: [apollo-client](<https://devfeed.tech/topics/apollo-client.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [GraphQL](<https://devfeed.tech/topics/graphql.md>), [React](<https://devfeed.tech/topics/react.md>)

Tags: [announcement](<https://devfeed.tech/tags/announcement.md>), [apollo-client](<https://devfeed.tech/tags/apollo-client.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [release](<https://devfeed.tech/tags/release.md>)

### AI overview

This article previews the Apollo Client 3 beta and focuses on its caching improvements. It describes normalized result caching, cache invalidation, garbage collection, cache eviction, and a unified cache configuration strategy.

### Source excerpt

Apollo Client's caching system is core to both the user experience and the developer experience it provides. As one of Apollo Client's most powerful features, the cache has been our biggest focus area while building Apollo Client 3. This major-version release will include plenty of other new features (such as a consolidated package that includes both React and Apollo Link functionality without requiring any additional imports), but the cache improvements are the most impactful and exciting.

## PostgreSQL Concurrency: an Article Series

DevFeed: [PostgreSQL Concurrency: an Article Series](<https://devfeed.tech/articles/postgresql-concurrency-an-article-series-34607.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2018/08/postgresql-concurrency-an-article-series/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2018-08-14T08:49:02Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [acid](<https://devfeed.tech/tags/acid.md>), [article](<https://devfeed.tech/tags/article.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [isolation-level](<https://devfeed.tech/tags/isolation-level.md>), [locking](<https://devfeed.tech/tags/locking.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [series](<https://devfeed.tech/tags/series.md>), [sql](<https://devfeed.tech/tags/sql.md>), [transactions](<https://devfeed.tech/tags/transactions.md>), [triggers](<https://devfeed.tech/tags/triggers.md>)

### AI overview

This article series explains how PostgreSQL handles concurrent access while maintaining data consistency. It covers data modification, isolation levels, locking, ACID transactions, concurrency-oriented data modeling, event processing, materialized views for caching, and triggers for transactionally correct cache maintenance.

### Source excerpt

PostgreSQL is a relational database management system. It's even the world's most advanced open source one of them. As such, as its core, Postgres solves concurrent access to a set of data and maintains consistency while allowing concurrent operations. In the PostgreSQL Concurrency series of articles here we did see several aspects of how to handle concurrent use cases of your application design with PostgreSQL. The main thing to remember is that a Database Management System first task is to handle concurrency access to the data for you.

## Computing and Caching

DevFeed: [Computing and Caching](<https://devfeed.tech/articles/computing-and-caching-34601.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2018/07/computing-and-caching/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2018-07-13T11:10:21Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [database](<https://devfeed.tech/tags/database.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

A PostgreSQL concurrency series article examines when to compute results and when to cache them for fast retrieval. It introduces SQL caching with materialized views, cache invalidation, snapshots, tables, and regular views.

### Source excerpt

Let's continue to dive in PostgreSQL Concurrency. In the previous article of the series, Modeling for Concurrency, we saw how to model your application for highly concurrent activity. It was a follow-up to the article entitled PostgreSQL Concurrency: Isolation and Locking, which was a primer on PostgreSQL isolation and locking properties and behaviors. Today's article takes us a step further and builds on what we did in the previous articles in our series. After having had all the characters from Shakespeare's A Midsummer Night's Dream tweet their own lines in our database in PostgreSQL Concurrency: Data Modification Language, and having had them like a retweet a lot in PostgreSQL Concurrency: Isolation and Locking, it's time to think about how to display our counters in an efficient way. In this article, we're going to think about when we should compute results and when we should cache them for instant retrieval, all within the SQL tooling. The SQL tooling for handling cache is a MATERIALIZED VIEW, and it comes with cache invalidation routines, of course.