RabbitMQ for Spring Boot Developers: Curriculum Blueprint (Comprehensive Redesign)

Phase 1 (blueprint only). No article content is generated until you approve. This is a full redesign, not constrained to the old topic set. It is comprehensive but non-redundant: closely related topics are merged into a single page so no concept is duplicated. Every core concept ships with at least one Mermaid diagram (flowchart for topologies, sequenceDiagram for lifecycles), worked Spring Boot code, and the Order/Inventory/Notification microservice scenario.

Design principles

Audience: intermediate-to-senior engineers who know Java/Spring Boot microservices but are new to RabbitMQ/AMQP/event-driven design.
Progressive + modular: each module is self-contained but builds on the previous; every module has learning outcomes, a diagram, a worked example, a practical, and a checkpoint.
Comprehensive, not redundant: each concept lives on exactly one page and is cross-linked elsewhere.
Stay on the RabbitMQ path: advanced/adjacent topics (Streams, Spring Cloud Stream) are clearly marked so they do not distract from the core learning path.
Replace in place: same _courses/rabbit-mq/; reuse existing permalinks where a module maps to an old one, add new permalinks otherwise.
Keep all ops content in a separate section: existing support material is preserved and relocated into Section 7 (Operations & Troubleshooting), lightly reframed.
Style: follows t5-course-content-style-guide.md: no em dashes, colons for labels, Mermaid diagrams, prose readable without the diagram.

Full Table of Contents (8 sections)

flowchart TD
    s1[1. Foundations and Setup]
    s2[2. Core Messaging and Routing]
    s3[3. Building with Spring AMQP]
    s4[4. Reliability and Resilience]
    s5[5. Event-Driven Architecture and Advanced Patterns]
    s6[6. Production Readiness]
    s7[7. Operations and Troubleshooting]
    s8[8. Capstone and Assessment]
    s1 --> s2 --> s3 --> s4 --> s5 --> s6 --> s7 --> s8

Section 1: Foundations and Setup

1. Why Messaging: REST vs RabbitMQ (/rabbit-mq/rest-vs-messaging) [REWRITE of 00]
- Async vs sync mindset, coupling, load-leveling, fan-out. Short appendix note: RabbitMQ vs Kafka vs SQS, when to pick which. Diagrams: two sequenceDiagrams (REST vs publish), flowchart LR of the four moving parts.
2. AMQP and the RabbitMQ Model (/rabbit-mq/core-concepts) [REWRITE of 01]
- AMQP 0-9-1 model, connections vs channels, vhosts, concept-to-Spring-AMQP glossary, at-least-once delivery. Diagram: flowchart LR of connection/channel/vhost model.
3. Environment Setup and the Management UI (/rabbit-mq/setup) [NEW]
- Docker run, ports, Management UI tour, rabbitmqctl basics, publish a test message by hand. Extracts/expands the setup practical from old module 0. Diagram: flowchart LR local dev topology.

Section 2: Core Messaging and Routing

4. Exchanges, Bindings and Routing Topologies (/rabbit-mq/exchanges-and-routing) [NEW]
- Direct, Topic, Fanout, Headers; default and alternate exchanges; exchange-to-exchange bindings. Diagrams: one flowchart per exchange type; topic routing-key table (* vs #).
5. Queues and Messages Deep Dive (/rabbit-mq/queues-and-messages) [NEW, merged: queue types + message anatomy]
- Queue durability/exclusivity/auto-delete, classic vs quorum vs streams (with when-to-use guide), max-length/overflow, lazy queues; message properties, headers, persistence/delivery mode, per-message vs per-queue TTL, priority queues. Single source of truth for TTL. Diagrams: flowchart TD queue-type decision guide; labeled flowchart of a message envelope.

Section 3: Building with Spring AMQP

6. First Producer and Consumer (with JSON serialization) (/rabbit-mq/spring-amqp-getting-started) [NEW, serialization merged in]
- spring-boot-starter-amqp, CachingConnectionFactory, RabbitTemplate, @RabbitListener, topology beans, auto-declaration, and Jackson2JsonMessageConverter with typed DTOs and type mapping. Advanced schema/versioning is deferred to the Event-Driven module. Diagram: sequenceDiagram of end-to-end round trip.
7. Consumer Acknowledgements and Prefetch (/rabbit-mq/acknowledgements-prefetch) [NEW]
- AUTO vs MANUAL ack, basicAck/basicNack/basicReject, requeue semantics, prefetch/QoS, concurrency/max-concurrency, throughput vs safety. Canonical home for prefetch mechanics (referenced by Performance). Diagram: sequenceDiagram of manual ack/nack.
8. Core Messaging Patterns (/rabbit-mq/messaging-patterns) [NEW]
- Work queues (competing consumers), pub/sub, routing, topics, RPC/request-reply (sendAndReceive, direct reply-to) in Spring AMQP. Diagram: one flowchart/sequenceDiagram per pattern.

Section 4: Reliability and Resilience

9. Reliable Publishing: Publisher Confirms and Returns (/rabbit-mq/publisher-confirms) [NEW]
- publisher-confirm-type, ConfirmCallback/ReturnsCallback, mandatory, correlation data, confirms vs transactions. Diagram: sequenceDiagram of confirm and unroutable-return.
10. Retry, Error Handling and Backoff (/rabbit-mq/retry-error-handling) [NEW]
- RetryOperationsInterceptor/RetryTemplate, DefaultErrorHandler, fatal vs non-fatal, exponential backoff, transient vs deterministic. Diagram: flowchart TD retry-then-reject decision tree.
11. Dead Letter Exchanges, DLQ, Delay and Parking-Lot (/rabbit-mq/dead-letter-exchanges) [NEW]
- QueueBuilder.deadLetterExchange(...), x-death, TTL-based delayed retry queues, parking-lot, reprocessing. Absorbs implementation content from 06-poison-messages-dlq.md (playbook stays as the troubleshooting view, cross-linked). Diagram: flowchart LR main to DLX to DLQ.
12. Idempotency, Ordering and Duplicate Handling (/rabbit-mq/idempotency-duplicates) [NEW]
- Why at-least-once forces idempotent consumers, dedup strategies, ordering caveats, single-active-consumer. Diagram: sequenceDiagram of redelivery/dedup.
13. Connection Recovery and Fault Tolerance (/rabbit-mq/connection-recovery) [NEW, concise]
- Automatic recovery, multiple addresses for clusters, listener container recovery, graceful shutdown, failover behavior. Diagram: sequenceDiagram of connection drop and recovery.

Section 5: Event-Driven Architecture and Advanced Patterns

14. Event-Driven Microservices with RabbitMQ (/rabbit-mq/event-driven-architecture) [NEW]
- Order publishes OrderCreated to Inventory + Notification; choreography vs orchestration; event vs command; event design and schema versioning. Diagram: flowchart TD full topology.
15. Transactional Outbox and Saga Patterns (/rabbit-mq/outbox-saga) [NEW]
- Dual-write problem, transactional outbox, saga choreography with compensation. Diagrams: flowchart outbox; sequenceDiagram saga with compensation.
16. RabbitMQ Streams (advanced, optional deep-dive) (/rabbit-mq/streams) [NEW, clearly marked optional]
- Stream queues, offsets, replay, super-streams, stream vs classic/quorum trade-offs. Includes a short “further learning” callout pointing to Spring Cloud Stream as a higher-level abstraction to explore later (no separate page). Positioned so readers can skip without breaking the main path. Diagram: flowchart stream offset/replay.

Section 6: Production Readiness

17. Security: Users, Permissions, vhosts, TLS/mTLS (/rabbit-mq/security) [NEW]
- Authn/authz model, per-vhost permissions, client-side TLS/mTLS, secrets handling. Diagram: flowchart of auth/permission flow.
18. Observability: Metrics, Tracing and Health (/rabbit-mq/observability) [NEW]
- Micrometer + Actuator, key broker/consumer metrics, Prometheus/Grafana, distributed tracing (OpenTelemetry). Diagram: flowchart LR metrics/trace pipeline.
19. Performance Tuning and Throughput (/rabbit-mq/performance) [NEW]
- Holistic tuning: batching, persistence trade-offs, connection/channel sizing, publisher throughput. References (does not repeat) prefetch/concurrency from module 7. Diagram: flowchart TD tuning decision guide.
20. Testing RabbitMQ Apps (/rabbit-mq/testing) [NEW]
- Testcontainers RabbitMQ, integration-testing listeners and confirms, Awaitility, serialization/contract tests. Diagram: flowchart test setup.

Section 7: Operations and Troubleshooting (separate section; existing content relocated + lightly reframed)

21. Cluster Architecture and High Availability (/rabbit-mq/aws-architecture) [KEEP, reframe intro] from 02-aws-architecture.md
22. Tooling Walkthrough (/rabbit-mq/tooling-walkthrough) [KEEP] from 03-tooling-walkthrough.md
23. Alert Playbooks (overview + 9) (/rabbit-mq/alert-playbooks/*) [KEEP] from 04-alert-playbooks/
24. Hands-On Lab: Incident Diagnosis (/rabbit-mq/hands-on-lab) [KEEP] from 05-hands-on-lab.md
25. Escalation and Communication (/rabbit-mq/escalation-communication) [KEEP] from 06-escalation-communication.md
26. Cheat Sheet (/rabbit-mq/cheat-sheet) [KEEP + augment with dev config keys] from 08-cheat-sheet.md

Section 8: Capstone and Assessment

27. Capstone Project: Build an Event-Driven Order System (/rabbit-mq/capstone) [NEW]
- End-to-end build tying together routing, confirms, DLX, idempotency, and observability across Order/Inventory/Notification. Diagram: flowchart TD final architecture.
28. Assessment (/rabbit-mq/assessment) [EXPAND of 07]
- Scenario questions across all sections (routing, acks, confirms, DLX, idempotency, streams, ops).

File-by-file disposition summary

Rewrite (reuse permalink):00-rest-vs-messaging.md, 01-core-concepts.md, 07-assessment.md, index.md.
New files (15): setup, exchanges-and-routing, queues-and-messages, spring-amqp-getting-started, acknowledgements-prefetch, messaging-patterns, publisher-confirms, retry-error-handling, dead-letter-exchanges, idempotency-duplicates, connection-recovery, event-driven-architecture, outbox-saga, streams, security, observability, performance, testing, capstone.
Keep + relocate (light intro reframe only):02-aws-architecture.md, 03-tooling-walkthrough.md, all of 04-alert-playbooks/, 05-hands-on-lab.md, 06-escalation-communication.md, 08-cheat-sheet.md.
Merged away (no separate page): message serialization (into getting-started), message anatomy (into queues-and-messages), Spring Cloud Stream (brief mention inside streams).
Deleted: none.

Supporting/scaffolding changes

File renumbering: re-prefix _topics/ files into the new 8-section order. Safe because routing uses front-matter permalink and cross-links use permalinks, not filenames.
Navigation: rewrite _data/courses/course-nav-menu/rabbit-mq.yml with the 8 section groups.
Course index: rewrite _courses/rabbit-mq/index.md (drop “Application Support”, new course-sections table, new “Who this is for”, updated CTA).
Registry: update title/description in _data/courses/course_list.yml if it carries support-oriented copy.
Lint: run ./scripts/lint-course-content.sh _courses/rabbit-mq/_topics after generation.

Phase 2 (await approval)

On approval we generate files sequentially, one module at a time, each with Mermaid diagram(s), realistic Order/Inventory/Notification code, cross-links, and a checkpoint, updating the nav YAML and index as we go.