Fresh data. Faster pages.

PaperCloak CacheConcierge

Cache the work. Coordinate the change.

A proposed .NET caching layer that coordinates changes through the existing database, with memory, Redis or both.

  • Developers of small and medium .NET sites
  • Teams with separate administration apps
  • Maintainers of multi-server catalogues

Why it exists

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.

Concept diagram of PaperCloak CacheConcierge: Map reads and writes, Define shared groups, Choose the cache mode, Measure and challenge.
Workflow concept, illustrated. Select the graphic to open it at full size.

From input to useful result

How the work moves through.

  1. Map reads and writes

    Identify expensive reusable data, every writer and the consequences of staleness. Choose an acceptable delay before deciding what to cache.

  2. Define shared groups

    Name dependencies consistently across readers, administration tools, scripts and jobs. Add change notes inside the same transactions as their related saves.

  3. Choose the cache mode

    Configure memory, optional Redis or both, with expiry, resource budgets and recovery settings matched to the deployment.

  4. 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.

Continue exploring

Related tools, distinct jobs.

Cache the work. Coordinate the change.

Explore the workflow Explore all software