Fix heading capitalization to use sentence case throughout

Co-authored-by: DougAnsonAustinTX <4755232+DougAnsonAustinTX@users.noreply.github.com>

Author: Copilot

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/baseline.md

@@ -15,7 +15,7 @@ The purpose of this baseline is to confirm:
 - Queue operations (create, publish, consume)
 - CLI tooling functionality (`rabbitmqctl` and `rabbitmqadmin`)
 
-### Check RabbitMQ Node Status
+### Check RabbitMQ node status
 Verify that the RabbitMQ node is operational and healthy.
 
 ```console
@@ -26,7 +26,7 @@ sudo rabbitmqctl status
 - Listeners are active on ports 5672 and 15672
 - Memory and disk space are within safe limits
 
-### Verify Enabled Plugins
+### Verify enabled plugins
 Confirm that the RabbitMQ management plugins are enabled.
 
 ```console
@@ -42,7 +42,7 @@ You should see an output similar to:
 [  ] rabbitmq_stream_management              4.2.0
 ```
 
-### Validate RabbitMQ Listeners
+### Validate RabbitMQ listeners
 Ensure RabbitMQ is listening on the required ports.
 
 ```console
@@ -58,7 +58,7 @@ Interface: [::], port: 25672, protocol: clustering, purpose: inter-node and CLI
 Interface: [::], port: 5672, protocol: amqp, purpose: AMQP 0-9-1 and AMQP 1.0
 ```
 
-### Download RabbitMQ Admin CLI Tool
+### Download RabbitMQ Admin CLI tool
 Download the rabbitmqadmin CLI tool from the local management endpoint.
 
 ```console
@@ -69,7 +69,7 @@ curl -u guest:guest http://localhost:15672/cli/rabbitmqadmin -o rabbitmqadmin
 ```console
 chmod +x rabbitmqadmin
 ```
-### Validate Queue Creation
+### Validate queue creation
 Create a test queue to validate write operations.
 
 ```console
@@ -81,7 +81,7 @@ You should see an output similar to:
 queue declared
 ```
 
-### Publish a Test Message
+### Publish a test message
 Send a test message to the queue.
 
 ```console
@@ -93,7 +93,7 @@ You should see an output similar to:
 Message published
 ```
 
-### Consume Message From Queue
+### Consume message from queue
 Retrieve messages from the queue to verify read functionality.
 
 ```console
@@ -109,7 +109,7 @@ You should see an output similar to:
 +-------------+----------+---------------+-------------+---------------+------------------+------------+-------------+
 ```
 
-### Verify Queue State
+### Verify queue state
 Confirm that the queue is empty after consumption.
 
 ```console

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/installation.md

@@ -9,7 +9,7 @@ layout: learningpathall
 ## Install RabbitMQ on GCP SUSE Arm64 VM
 This guide describes a **step-by-step installation of RabbitMQ** on a **Google Cloud Platform SUSE Linux Arm64 virtual machine**, using **RPM packages** for both **Erlang** and **RabbitMQ Server**.
 
-RabbitMQ requires Erlang to be installed before setting up the server.
+RabbitMQ needs Erlang to be installed before setting up the server.
 
 
 ### Prerequisites
@@ -18,14 +18,14 @@ RabbitMQ requires Erlang to be installed before setting up the server.
 - Root or sudo privileges
 - Outbound internet access
 
-### Refresh System Repositories
+### Refresh system repositories
 This step updates the system’s package list so the operating system knows about the latest software available from its repositories.
 
 ```console
 sudo zypper refresh
 ```
 
-### Install Required System Utilities
+### Install required system utilities
 You can install the basic tools needed to download and manage packages.
 
 ```console
@@ -40,7 +40,7 @@ wget https://github.com/rabbitmq/erlang-rpm/releases/download/v26.2.5/erlang-26.
 sudo rpm -Uvh erlang-26.2.5-1.el8.aarch64.rpm
 ```
 
-### Verify Erlang Installation
+### Verify Erlang installation
 Confirm that Erlang is installed correctly.
 
 ```console
@@ -68,14 +68,14 @@ You can view [this release note](https://github.com/rabbitmq/rabbitmq-server/blo
 The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) recommends RabbitMQ version 3.11.0, the minimum recommended on Arm platforms.
 {{% /notice %}}
 
-### Enable and Start RabbitMQ Service
+### Enable and start RabbitMQ service
 Enable RabbitMQ to start automatically on boot and start the service immediately.
 
 ```console
 sudo systemctl enable rabbitmq-server --now
 ```
 
-### Verify RabbitMQ Service Status
+### Verify RabbitMQ service status
 Check the status of the RabbitMQ service.
 
 ```console
@@ -84,7 +84,7 @@ sudo systemctl status rabbitmq-server
 
 The service should be in an active (running) state.
 
-### Enable RabbitMQ Management Plugin
+### Enable RabbitMQ management plugin
 Enable the RabbitMQ management plugin to access the web-based dashboard.
 
 ```console
@@ -98,7 +98,7 @@ Restart RabbitMQ to apply plugin changes.
 sudo systemctl restart rabbitmq-server
 ```
 
-### Verify RabbitMQ Version
+### Verify RabbitMQ version
 Confirm the installed RabbitMQ version.
 
 ```console
@@ -111,7 +111,7 @@ You should see an output similar to:
 4.2.0
 ```
 
-### Access RabbitMQ Management UI
+### Access RabbitMQ management UI
 Create a new RabbitMQ user for remote access.
 
 Create a new `admin` user by running these commands on the VM:

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case1.md

@@ -16,7 +16,7 @@ This use case demonstrates how RabbitMQ enables event-driven architectures using
 
 The use case models an **event-driven system**, where order-related events are published and processed asynchronously by workers.
 
-### Use Case Overview
+### Use case overview
 
 **Scenario:**  
 An application publishes order-related events (`order.created`, `order.updated`, etc.) to RabbitMQ. A background worker consumes these events from a queue and processes them independently.
@@ -38,7 +38,7 @@ This architecture improves scalability, fault tolerance, and system decoupling.
 - Python 3 installed
 - Network access to RabbitMQ broker
 
-### Declare a Topic Exchange
+### Declare a topic exchange
 Create a durable topic exchange to route events based on routing keys.
 
 ```console
@@ -49,7 +49,7 @@ Create a durable topic exchange to route events based on routing keys.
 - Routes messages using wildcard-based routing keys (for example, order.*).
 - Ensures the exchange survives broker restarts.
 
-### Declare a Durable Queue
+### Declare a durable queue
 Create a durable queue to store order-related events.
 
 ```console
@@ -65,7 +65,7 @@ You should see an output similar to:
 queue declared
 ```
 
-### Bind Queue to Exchange
+### Bind queue to exchange
 Bind the queue to the exchange using a topic routing pattern.
 
 ```console
@@ -86,7 +86,7 @@ This binding ensures the queue receives all messages with routing keys such as:
 - order.updated
 - order.completed
 
-### Publish an Event Message
+### Publish an event message
 Publish a sample order event to the exchange.
 
 ```console
@@ -102,15 +102,15 @@ You should see an output similar to:
 Message published
 ```
 
-### Install Python Dependencies
+### Install Python dependencies
 Install pip and the pika RabbitMQ client library.
 
 ```console
 sudo zypper install -y python3-pip
 pip install pika
 ```
 
-### Create the Worker Script
+### Create the worker script
 Create a Python worker file to process messages from a queue.
 
 A **Python worker** was created to process messages from a RabbitMQ queue (jobs) using the pika library. The queue is durable, ensuring message persistence. The worker implements fair dispatch (prefetch_count=1) and manual acknowledgments to reliably process each job without loss. Messages were successfully published to the queue using rabbitmqadmin, and the worker consumed them as expected.
@@ -162,7 +162,7 @@ channel.basic_consume(
 channel.start_consuming()
 ```
 
-### Start the Worker
+### Start the worker
 Run the worker process.
 
 ```console
@@ -174,7 +174,7 @@ You should see an output similar to:
 The worker started. Waiting for jobs...
 ```
 
-### Publish Job Messages
+### Publish job messages
 From another SSH terminal, publish a job message.
 
 ```console
@@ -202,7 +202,7 @@ Worker started. Waiting for jobs...
 ```
 Press "CTRL-C" to exit the worker application.
 
-## Use Case Validation
+## Use case validation
 
 - Event routing via topic exchanges functions correctly  
 - Durable queues and acknowledgments ensure reliable message processing  

content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case2.md

@@ -10,7 +10,7 @@ layout: learningpathall
 ## WhatsApp Notification Use Case using RabbitMQ  
 This document demonstrates a **real-world asynchronous messaging use case** where RabbitMQ is used to process WhatsApp notifications reliably using a worker-based architecture.
 
-### Use Case Overview
+### Use case overview
 
 In many production systems, sending WhatsApp notifications must be:
 - Reliable
@@ -19,7 +19,7 @@ In many production systems, sending WhatsApp notifications must be:
 
 RabbitMQ is used as a **message broker** to decouple message production from message consumption.
 
-### Architecture Flow
+### Architecture flow
 
 1. Application publishes a message to RabbitMQ
 2. RabbitMQ routes the message to a queue
@@ -34,15 +34,15 @@ RabbitMQ is used as a **message broker** to decouple message production from mes
 - Python 3.8+
 - `pika` Python client library installed
 
-### Install Python Dependencies
+### Install Python dependencies
 Installs Python and the RabbitMQ Python client needed to build a consumer.
 
 ```console
 sudo zypper install -y python3 python3-pip
 pip3 install pika
 ```
 
-### RabbitMQ Topology
+### RabbitMQ topology
 This use case uses a direct exchange topology for exact-match routing.
 
 **Exchanges**
@@ -56,7 +56,7 @@ This use case uses a direct exchange topology for exact-match routing.
 - Routing key: **whatsapp** – Ensures only WhatsApp-related messages are routed.
 - Queue: **whatsapp.notifications**– Final destination where messages are delivered for processing.
 
-### Declare RabbitMQ Resources
+### Declare RabbitMQ resources
 Creates the required exchange, queue, and binding for WhatsApp notifications.
 
 - `Declare exchange`: Creates a durable direct exchange named notifications to route messages using exact routing keys.
@@ -142,7 +142,7 @@ Confirms topology correctness before consuming messages.
 +---------------+------------------------+------------------------+
 ```
 
-### WhatsApp Worker Implementation
+### WhatsApp worker implementation
 The worker attaches as a **blocking consumer** to the `whatsapp.notifications` queue and processes incoming messages.
 
 Create a `whatsapp_worker.py` file with the content below:
@@ -202,7 +202,7 @@ print("[DEBUG] Starting consumer loop (this should block)...")
 channel.start_consuming()
 ```
 
-### Start the Worker
+### Start the worker
 Run the worker in a dedicated terminal session:
 
 ```console
@@ -223,7 +223,7 @@ WhatsApp Worker started. Waiting for messages...
 
 The process must block without returning to the shell prompt.
 
-### Publish a Test Message
+### Publish a test message
 From another SSH terminal: Publishes a WhatsApp notification message to RabbitMQ.
 
 ```console
@@ -241,7 +241,7 @@ You should see the following output from whatsapp_worker.py that is running in t
 [Worker] Message sent successfully
 ```
 
-### Message Consumption Validation
+### Message consumption validation
 The worker terminal displays logs similar to:
 
 ```output
@@ -262,7 +262,7 @@ WhatsApp Worker started. Waiting for messages...
 
 This validates the end-to-end message flow.
 
-### Verify Queue State
+### Verify queue state
 
 ```console
 ./rabbitmqadmin list queues name messages consumers