CacheConcierge would coordinate cached data across public servers and separate administration tools.
Caching a menu is straightforward. Keeping it correct across several servers is harder when a separate administration application edits the database. A secret cache-clear URL can fail quietly or reach only one server. CacheConcierge proposes coordination through the shared database.
The writer would save its business change and a short invalidation note in the same transaction. Each server would inspect committed notes and discard only affected cache groups. Memory is the starting mode; Redis and combined memory-plus-Redis modes are optional. The database remains authoritative, and the site chooses which data can tolerate a configured freshness delay.
What it is designed to do
The capabilities, in detail.
Replace cache-clear links with transactional notes, targeted invalidation and explicit freshness settings.
Coordinate through committed changes
Transactional notes would connect a successful save to the data groups it invalidates. A rolled-back save should clear nothing. Database time, overlapping read windows and replay rules are specified to address delayed commits and missed checks. These are proposed correctness mechanisms, with failure cases that must be demonstrated before release.
Invalidate useful groups, not the whole site
Cached items would declare dependencies such as a category, menu or route lookup. A writer would name the changed group rather than know every cache key. Version checks are intended to reject stale values built during a concurrent save, avoiding the race where old data re-enters the cache just after invalidation.
Choose memory, Redis or both
The proposed API builds around .NET HybridCache, with configuration selecting local memory, shared Redis, combined operation or Off mode. Redis would improve sharing and invalidation delivery where useful, while the database change log remains the recovery path. SQL Server is the first planned database; further adapters need separate implementation.
Make freshness and recovery visible
The specification proposes a default maximum change delay of 30 seconds, adjustable for the site. Expiry provides a backstop, while recovery replays missed notes within the defined retention horizon. Redis failure should degrade toward memory and database behavior. Optional serving of older data on error must be explicit rather than a hidden default.
Help developers make defensible choices
The planned setup kit combines project-analysis prompts, group design, risk review and before-and-after checks. Diagnostics would show invalidation lag, cache state and the cause of stale results. Per-user data requires separate keys and budgets where appropriate; sessions, carts and checkout decisions are outside the ordinary shared-cache use case.
Workflow concept, illustrated. Select the graphic to open it at full size.
From input to useful result
How the work moves through.
01
Map reads and writes
Identify expensive reusable data, every writer and the consequences of staleness. Choose an acceptable delay before deciding what to cache.
02
Define shared groups
Name dependencies consistently across readers, administration tools, scripts and jobs. Add change notes inside the same transactions as their related saves.
03
Choose the cache mode
Configure memory, optional Redis or both, with expiry, resource budgets and recovery settings matched to the deployment.
04
Measure and challenge
Compare database calls and response behavior, then test updates, rollbacks, delayed commits, outages and restarts against the freshness target.
A concrete example
A category edit reaches every public server
A catalogue site has a separate administration application and three public web servers. An editor changes a category description. The intended integration saves that change and its category invalidation note atomically, allowing each server to discard dependent data without flushing unrelated menus and categories.
If one server misses an optional Redis notification, its database check should still catch the note. A delayed request building an older category value should fail the dependency-version check after invalidation. Those outcomes are specification acceptance cases, not measured results. Checkout still validates its business rules against authoritative data rather than trusting cached display information.
What comes out of the work
Results you can understand.
A proposed integration contract
Standard cache calls with transactional group invalidation.
Freshness and health diagnostics
Planned visibility into change propagation, errors and cache behavior.
Reviewable adoption evidence
Intended setup reports, targeted migration steps and measured before-and-after checks.
Built around
Principles that shape the product.
Database-coordinated invalidation groups
Memory, Redis and combined cache modes
Explicit freshness, recovery and observability rules
Connected work
A clear role in the family.
CMS is an adjacent publishing use case for data that changes through a separate administration workflow.
Tools is the broader developer-library direction; CacheConcierge has its own proposed .NET caching contract.
Worth understanding
Questions and boundaries.
Is there a package to install today?
No. Draft 10 specifies the intended product; it is not a released library or verified drop-in replacement.
Does every installation require Redis?
No. The design coordinates through the existing database. Redis is an optional cache and notification layer.
Does it guarantee instant correctness for every value?
No. Freshness is bounded by chosen settings and operating conditions. Business validation, uncaptured writes and failure behavior remain the application's responsibility.