backend-queue

Select and implement message queue technologies and patterns for distributed systems.

Updated Mar 2, 2026
One-click install
npx skills add https://github.com/Genuineh/fus --skill backend-queue
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-queue
Source: https://github.com/Genuineh/fus/tree/main/skills/backend-queue
Command: npx skills add https://github.com/Genuineh/fus --skill backend-queue

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps developers choose the right message queue technology and implement common messaging patterns for distributed systems.

Core Features & Use Cases

  • Queue Selection Guidance: Provides a matrix and criteria for selecting between RabbitMQ, Kafka, Redis Streams, SQS, and NATS.
  • Pattern Implementation: Explains and illustrates Point-to-Point, Pub/Sub, and Saga patterns.
  • Code Examples: Offers basic implementation snippets in Rust for RabbitMQ and Kafka.
  • Best Practices: Details message design and idempotent consumer patterns.
  • Use Case: A backend engineer needs to decide between Kafka and RabbitMQ for a new microservice architecture and wants to understand how to implement a reliable event-driven workflow.

Quick Start

Guide me in selecting a message queue for a high-throughput, low-latency event streaming use case.

Frequently Asked Questions about backend-queue

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I choose the right message queue for high-throughput distributed systems?

To choose a message queue for distributed systems, evaluate throughput and latency requirements against a selection matrix covering RabbitMQ, Kafka, Redis Streams, SQS, and NATS. This Skill provides criteria comparing these technologies to match your specific event streaming use case.

What is the difference between pub/sub and saga patterns in event-driven architectures?

Pub/sub patterns broadcast messages to multiple subscribers asynchronously, while saga patterns coordinate long-running distributed transactions across microservices. This Skill illustrates both message queue patterns with code examples to help implement reliable event-driven workflows.

Can I implement idempotent consumers with RabbitMQ and Kafka?

Yes, you can implement idempotent consumers with RabbitMQ and Kafka to ensure reliable asynchronous communication. This Skill details message design best practices and idempotent consumer patterns, providing basic implementation snippets in Rust for both technologies.

When should I use Kafka instead of RabbitMQ for microservices?

Use Kafka instead of RabbitMQ when microservices require high-throughput event streaming and message persistence, whereas RabbitMQ is better suited for complex routing and point-to-point messaging. This Skill provides selection guidance based on specific architectural needs.

How do I implement point-to-point messaging in Rust?

To implement point-to-point messaging in Rust, use the basic implementation snippets provided by this Skill for RabbitMQ and Kafka. It demonstrates how to establish reliable asynchronous communication channels between distributed system components.