Are there any message queue backed stores that handle ephemeral workload spikes without heavy persistence overhead?

Yes. If your goal is to absorb short-lived spikes without paying a big durable-storage cost on every message, there are a few patterns and systems that fit.

Good fits

1. Redis Streams / Redis Lists / Redis-based queues

• Very low latency
• Can be configured with lightweight persistence or even mostly-memory operation
• Good for ephemeral buffers, task queues, and burst absorption
• Tradeoff: durability is weaker than full log-based brokers if you minimize persistence

2. NATS JetStream

• NATS itself is very lightweight and designed for high-throughput, low-latency messaging
• JetStream adds optional persistence, but you can tune it for bounded retention and ephemeral workloads
• Good when you want queue semantics without Kafka-like storage overhead

3. RabbitMQ with transient messages / lazy queues

• Supports non-durable queues and transient messages
• Can help with burst handling without forcing every message onto disk immediately
• Tradeoff: persistence tuning is more operationally nuanced than Redis/NATS

4. Apache Pulsar with retention tuning

• More heavyweight than the above, but flexible
• Can be configured with short retention and tiered storage
• Better if you may later need stronger durability or replay

5. In-memory data grid / ephemeral broker setups

Examples:

• Hazelcast
• Apache Ignite
• ActiveMQ Artemis in non-persistent mode

These are useful when the workload is truly temporary and losing some messages is acceptable.

---

If you want “spike absorption” specifically

A common architecture is:

• Front-end queue in memory or low-persistence mode
• Workers drain it quickly
• Autoscaling consumers
• Backpressure / overflow to durable store only when needed

This gives you the benefit of handling bursts without writing everything to disk.

---

Best options by use case

• Lowest overhead, ephemeral tasks: Redis or NATS
• Classic queue semantics: RabbitMQ
• Need replay later: Kafka/Pulsar, but these are heavier
• Very temporary internal buffering: in-memory broker or non-persistent mode

---

Important caveat

If you truly need:

• no message loss,
• guaranteed ordering,
• and low persistence overhead,

those goals conflict somewhat. The lighter the persistence, the more you rely on memory and accept risk during failure.

If you want, I can give you a short comparison table of Redis vs NATS vs RabbitMQ for ephemeral spike buffering.