This is a submission for the Redis AI Challenge: Beyond the Cache.
What I Built
I built an AI-powered incident management platform that doesn’t just track incidents—it actively tries to fix them automatically in real-time.
Instead of being a passive dashboard, the system reacts instantly to new issues by triggering an autofix workflow backed by Redis Streams and JSON storage.
When an incident is detected, Redis:
- Stores it as the primary database in JSON format.
- Pushes it into a Redis Stream for processing.
- Supports real-time WebSocket updates to all connected clients so the UI reflects changes instantly.
The system can:
- Detect: New incidents are pushed into Redis JSON.
- Fix: A service attempts context-specific fixes.
- Update: The dashboard is refreshed via WebSocket with status changes.
This makes the platform not just a monitoring tool—but a self-healing system.
Demo
Github Link: https://github.com/StephCurry07/Redis-IncidentResponseDashboard
📹 Video Walkthrough: YouTube Link
Screenshots:
How I Used Redis 8
I used Redis 8 well beyond simple caching:
-
Primary Database (RedisJSON)
- Incidents are stored directly in RedisJSON with rich metadata (
severity,status,description,tags). - Updates are instant and atomic—ideal for high-frequency changes from multiple services.
- Incidents are stored directly in RedisJSON with rich metadata (
-
Real-time Streams for Autofix Pipeline
- Every new incident is appended to a Redis Stream (
incident_stream). - A background AI service consumes from this stream to attempt automated fixes, logging results back to Redis.
- Every new incident is appended to a Redis Stream (
-
Pub/Sub for UI Live Updates
- On every update (fix, status change), a message is published to
incident_updates. - The frontend listens over WebSockets for instant UI refreshes without polling.
- On every update (fix, status change), a message is published to
-
Full-Text Search (RediSearch) (optional enhancement)
- Allows users to quickly filter incidents by description, tags, or owner with sub-millisecond search results.
Why It’s Beyond the Cache
Redis is the operational core of this system—without it, real-time reaction, distributed event processing, and instant updates wouldn’t be possible.
It’s:
- A primary DB (RedisJSON)
- A data pipeline (Streams)
- A search engine (RediSearch)
... all in one.
Instead of just serving cached reads, Redis orchestrates the entire lifecycle from incident detection → AI fix → live UI updates.
Next Steps
- Implement AI autofix logic to handle different infrastructure types.
- Integrate with CI/CD pipelines for proactive rollback.
- Add historical analytics using RedisTimeSeries.
Top comments (1)
Really cool project! Love how you used RedisJSON, Streams, and Pub/Sub to make it a self-healing system instead of just a dashboard. Excited to see how the AI autofix evolves!