How should I handle cache invalidation when related Eloquent models are updated?

[nasrinlipi41]

I have a Laravel application where I cache data for performance. Some cached data depends on multiple related Eloquent models.

For example, I have:

$subject = Subject::with('nodes.resources')->find($id);

Cache::remember(
    "subject:{$id}",
    now()->addDay(),
    fn () => $subject
);

The problem is that when a Node or Resource is created, updated, or deleted, the cached Subject becomes stale.

I could manually clear the subject cache from every observer, but as the application grows, this starts becoming difficult to maintain.

What would be the recommended Laravel approach for handling this?

Should I:

1. Invalidate the parent cache from Eloquent observers?
2. Use model events / observers with cache tags?
3. Use a different cache-key/versioning strategy?
4. Avoid caching the entire Eloquent relationship tree?

I'm particularly interested in how you would design this for a larger Laravel application where the relationships and cached queries may become more complex.

What would be considered the most maintainable approach in Laravel?

[trtajim]

For a larger Laravel application, I’d prefer explicit cache invalidation, but keep it centralized rather than scattering Cache::forget() calls everywhere.

For example, when a Node or Resource changes, invalidate the affected Subject cache from an observer or service:

Cache::forget("subject:{$subjectId}");

I wouldn't rely on cache tags to automatically handle Eloquent relationships—they don't understand your dependency graph.

Also, avoid caching large Eloquent relationship trees unless necessary. Cache expensive query results or computed data where possible.

For more complex/high-churn caches, versioned keys can be useful:

$version = Cache::get("subject:{$id}:version", 1);
$key = "subject:{$id}:v{$version}";

Then increment the version whenever related data changes.

So, in short: centralized explicit invalidation for most applications; versioned keys when the dependency graph becomes complex.