diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md
index 72051a667f..689005c3dd 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md
@@ -1,21 +1,20 @@
 ---
-title: Deploy RabbitMQ on Google Cloud C4A (Arm-based Axion VMs)
-
-draft: true
-cascade:
-    draft: true
+title: Deploy RabbitMQ on Arm64 Cloud Platforms (Azure & GCP)
 
 minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for software engineers and platform engineers migrating messaging and event-driven workloads from x86_64 to Arm-based servers, specifically on Google Cloud C4A virtual machines powered by Axion processors.
+who_is_this_for: This is an introductory topic for software engineers and platform engineers migrating messaging and event-driven workloads from x86_64 to Arm-based servers, specifically on Microsoft Azure Cobalt 100 Arm processors and Google Cloud C4A virtual machines powered by Axion processors. 
 
 learning_objectives:
+  - Provision Arm-based Linux virtual machines on Google Cloud (C4A with Axion processors) and Microsoft Azure (Cobalt 100)
   - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors)
-  - Install and configure RabbitMQ on a SUSE Arm64 (C4A) instance
-  - Validate RabbitMQ deployment using baseline messaging tests
-  - Implement real-world RabbitMQ use cases such as event-driven processing and notification pipelines
+  - Install and configure RabbitMQ on Arm64 Linux (SUSE SLES on GCP and Ubuntu Pro 24.04 on Azure)
+  - Build and configure required Erlang versions for RabbitMQ on Arm64
+  - Validate RabbitMQ deployments using baseline messaging and connectivity tests
+  - Implement practical RabbitMQ use cases such as event-driven processing and notification pipelines on Arm-based infrastructure
 
 prerequisites:
+  - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6).
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
   - Basic understanding of message queues and messaging concepts (publishers, consumers)
   - Familiarity with Linux command-line operations
@@ -25,7 +24,6 @@ author: Pareena Verma
 ##### Tags
 skilllevels: Introductory
 subjects: Databases
-cloud_service_providers: Google Cloud
 
 armips:
   - Neoverse
@@ -48,6 +46,11 @@ further_reading:
       link: https://cloud.google.com/docs
       type: documentation
 
+  - resource:
+      title: Azure Virtual Machines documentation
+      link: https://learn.microsoft.com/azure/virtual-machines/
+      type: documentation    
+
   - resource:
       title: RabbitMQ documentation
       link: https://www.rabbitmq.com/documentation.html 
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_baseline.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_baseline.md
new file mode 100644
index 0000000000..cf53643d05
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_baseline.md
@@ -0,0 +1,141 @@
+---
+title: RabbitMQ Baseline Testing
+weight: 5
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Run a Baseline Test With RabbitMQ 
+This section validates a working **RabbitMQ 4.2.0** installation with **Erlang OTP 26** on an **Azure Ubuntu Arm64 VM**.  
+
+All steps are **CLI-only** and suitable for baseline verification.
+
+### Verify RabbitMQ Service Status
+
+```console
+sudo systemctl status rabbitmq
+```
+
+### Verify Erlang Version
+RabbitMQ depends on Erlang. This step ensures the broker is using Erlang OTP 26.
+
+```console
+erl -eval 'io:format("~s~n", [erlang:system_info(system_version)]), halt().' -noshell
+```
+
+### Verify RabbitMQ Version
+Confirm the installed RabbitMQ version.
+
+```console
+rabbitmqctl version
+```
+
+### Verify Enabled Plugins
+List all enabled plugins and confirm that the management plugins are active.
+
+```console
+rabbitmq-plugins list -e
+```
+
+```output
+Listing plugins with pattern ".*" ...
+ Configured: E = explicitly enabled; e = implicitly enabled
+ | Status: * = running on rabbit@lpprojectubuntuarm64
+ |/
+[E*] rabbitmq_management       4.2.0
+[e*] rabbitmq_management_agent 4.2.0
+[e*] rabbitmq_web_dispatch     4.2.0
+````
+
+This confirms that:
+
+- The management UI is enabled
+- Required supporting plugins are running
+
+### Check RabbitMQ Node Health
+Retrieve detailed runtime and resource information for the RabbitMQ node.
+
+```console
+rabbitmqctl status
+```
+This confirms that:
+
+- Node is running
+- No alarms are reported
+- Erlang version matches OTP 26
+
+### Ensure RabbitMQ Configuration Directory Permissions
+RabbitMQ requires write access to its configuration directory for plugin management.
+
+```console
+sudo mkdir -p /opt/rabbitmq/etc/rabbitmq
+sudo chown -R azureuser:azureuser /opt/rabbitmq/etc/rabbitmq
+```
+
+### Create a Baseline Test Virtual Host
+Create an isolated virtual host for baseline testing.
+
+```console
+rabbitmqctl add_vhost test_vhost
+rabbitmqctl set_permissions -p test_vhost guest ".*" ".*" ".*"
+```
+
+This ensures:
+
+- Tests do not interfere with default workloads
+- Full permissions are available for validation
+
+### Download RabbitMQ Admin CLI
+Download the `rabbitmqadmin` CLI tool from the management endpoint.
+
+```console
+wget http://localhost:15672/cli/rabbitmqadmin -O ~/rabbitmqadmin
+chmod +x ~/rabbitmqadmin
+```
+
+This CLI is used to perform queue and message operations.
+
+### Declare a Test Queue
+Create a non-durable test queue in the test virtual host.
+
+```console
+~/rabbitmqadmin -V test_vhost declare queue name=test durable=false
+```
+
+### Publish a Test Message
+Publish a sample message to the test queue using the default exchange.
+
+```console
+~/rabbitmqadmin -V test_vhost publish \
+  exchange=amq.default \
+  routing_key=test \
+  payload="Hello RabbitMQ"
+```
+
+This validates:
+
+- Message routing
+- Exchange-to-queue binding behavior
+
+### Consume The Test Message
+Retrieve and remove the message from the queue.
+
+```console
+~/rabbitmqadmin -V test_vhost get queue=test count=1
+```
+
+You should see an output similar to:
+
+```output
++-------------+----------+---------------+----------------+---------------+------------------+------------+-------------+
+| routing_key | exchange | message_count |    payload     | payload_bytes | payload_encoding | properties | redelivered |
++-------------+----------+---------------+----------------+---------------+------------------+------------+-------------+
+| test        |          | 0             | Hello RabbitMQ | 14            | string           |            | False       |
++-------------+----------+---------------+----------------+---------------+------------------+------------+-------------+
+```
+
+- Message payload: Hello RabbitMQ
+- Queue becomes empty after consumption
+
+This baseline validates a healthy RabbitMQ 4.2.0 deployment running on Erlang/OTP 26 on an Azure Ubuntu Arm64 VM. Core components, plugins, and node health were verified, followed by successful message publish and consume operations.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_installation.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_installation.md
new file mode 100644
index 0000000000..703a0a3311
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_installation.md
@@ -0,0 +1,155 @@
+---
+title: Install RabbitMQ on Microsoft Azure Cobalt 100
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Install RabbitMQ on Azure Cobalt 100
+This guide describes the end-to-end installation of RabbitMQ 4.2.0 on an Azure Cobalt 100 (Arm-based) Ubuntu Pro 24.04 virtual machine. It covers system preparation, Erlang installation, RabbitMQ setup, service configuration, and validation with the management plugin enabled.
+
+### Update system and install build dependencies
+This step ensures the operating system is up to date and installs all required packages needed to build Erlang and run RabbitMQ reliably.
+
+```console
+sudo apt update
+sudo apt install -y build-essential libssl-dev libncurses-dev libtinfo-dev \
+                    libgl1-mesa-dev libglu1-mesa-dev libpng-dev libssh-dev \
+                    unixodbc-dev wget tar xz-utils git
+```
+
+### Build and install Erlang OTP 26
+RabbitMQ 4.2.0 requires Erlang OTP 26. This section builds Erlang from source to ensure full compatibility on Arm64.
+
+```console
+# Clone Erlang source
+git clone https://github.com/erlang/otp.git
+cd otp
+
+# Checkout OTP 26 branch
+git checkout OTP-26
+
+# Clean previous builds
+make clean
+
+# Configure build with SSL/crypto support
+./configure --prefix=/usr/local/erlang-26 \
+            --enable-smp-support \
+            --enable-threads \
+            --enable-kernel-poll \
+            --with-ssl
+
+# Build and install
+make -j$(nproc)
+sudo make install
+```
+### Make Erlang PATH persistent (IMPORTANT)
+This step ensures the Erlang binaries are permanently available in the system PATH across sessions and reboots.
+
+```console
+echo 'export ERLANG_HOME=/usr/local/erlang-26' | sudo tee /etc/profile.d/erlang.sh
+echo 'export PATH=$ERLANG_HOME/bin:$PATH' | sudo tee -a /etc/profile.d/erlang.sh
+```
+
+### Download and install RabbitMQ
+This section downloads the official RabbitMQ 4.2.0 generic Unix distribution and installs it under `/opt/rabbitmq`.
+
+```console
+cd ~
+wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v4.2.0/rabbitmq-server-generic-unix-4.2.0.tar.xz
+sudo mkdir -p /opt/rabbitmq
+sudo tar -xvf rabbitmq-server-generic-unix-4.2.0.tar.xz -C /opt/rabbitmq --strip-components=1
+
+# Create directories for logs and database
+sudo mkdir -p /var/lib/rabbitmq /var/log/rabbitmq
+sudo chown -R $USER:$USER /var/lib/rabbitmq /var/log/rabbitmq
+```
+
+#### Update PATH environment variable
+This step makes RabbitMQ CLI tools available in the current shell and should be persisted for future sessions.
+
+```console
+export PATH=/usr/local/erlang-26/bin:/opt/rabbitmq/sbin:$PATH
+```
+
+Add this line to `~/.bashrc` or `~/.profile` for persistence.
+
+### Configure RabbitMQ systemd service
+This section configures RabbitMQ to run as a managed systemd service, enabling automatic startup and controlled lifecycle management.
+
+Create `/etc/systemd/system/rabbitmq.service`:
+
+```ini
+[Unit]
+Description=RabbitMQ broker
+After=network.target
+
+[Service]
+Type=simple
+User=azureuser
+Group=azureuser
+
+Environment=HOME=/home/azureuser
+Environment=RABBITMQ_HOME=/opt/rabbitmq
+Environment=RABBITMQ_MNESIA_BASE=/var/lib/rabbitmq
+Environment=RABBITMQ_LOG_BASE=/var/log/rabbitmq
+Environment=PATH=/usr/local/erlang-26/bin:/opt/rabbitmq/sbin:/usr/bin
+
+ExecStart=/opt/rabbitmq/sbin/rabbitmq-server
+ExecStop=/opt/rabbitmq/sbin/rabbitmqctl shutdown
+
+Restart=on-failure
+RestartSec=10
+LimitNOFILE=65536
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Reload systemd and start RabbitMQ:
+
+```console
+sudo systemctl daemon-reload
+sudo systemctl enable rabbitmq
+sudo systemctl start rabbitmq
+sudo systemctl status rabbitmq
+```
+
+### Enable RabbitMQ management plugin
+This step enables the RabbitMQ management plugin, which provides a web-based UI and HTTP API for monitoring and administration.
+
+```console
+# Ensure config directory exists
+sudo mkdir -p /opt/rabbitmq/etc/rabbitmq
+sudo chown -R $USER:$USER /opt/rabbitmq/etc/rabbitmq
+
+# Enable management plugin
+rabbitmq-plugins enable rabbitmq_management
+```
+
+### Verify installation
+This section validates that both Erlang and RabbitMQ are installed correctly and running with the expected versions.
+
+**Erlang version:**
+
+```console
+erl -eval 'io:format("~s~n", [erlang:system_info(system_version)]), halt().' -noshell
+```
+
+You should see an output similar to:
+```output
+Erlang/OTP 26 [erts-14.2.5.12] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit]
+```
+
+**Verify RabbitMQ version:**
+
+```console
+rabbitmqctl version
+```
+
+You should see an output similar to:
+```output
+4.2.0
+```
+RabbitMQ 4.2.0 is successfully installed on an Azure Cobalt 100 Ubuntu Pro 24.04 Arm64 VM with systemd management, persistent storage, logging, and the management plugin enabled.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_instance.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_instance.md
new file mode 100644
index 0000000000..14e189efa0
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/azure_instance.md
@@ -0,0 +1,50 @@
+---
+title: Create an Arm based cloud virtual machine using Microsoft Cobalt 100 CPU 
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Introduction
+
+There are several ways to create an Arm-based Cobalt 100 virtual machine: the Microsoft Azure console, the Azure CLI tool, or using your choice of IaC (Infrastructure as Code). This guide will use the Azure console to create a virtual machine with Arm-based Cobalt 100 Processor. 
+
+This learning path focuses on the general-purpose virtual machine of the D series. Please read the guide on [Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series) offered by Microsoft Azure.  
+
+If you have never used the Microsoft Cloud Platform before, please review the microsoft [guide to Create a Linux virtual machine in the Azure portal](https://learn.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal?tabs=ubuntu). 
+
+#### Create an Arm-based Azure Virtual Machine 
+
+Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other virtual machine in Azure. To create an Azure virtual machine, launch the Azure portal and navigate to "Virtual Machines".
+1. Select "Create", and click on "Virtual Machine" from the drop-down list.
+2. Inside the "Basic" tab, fill in the Instance details such as "Virtual machine name" and "Region".
+3. Choose the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select “Arm64” as the VM architecture.
+4. In the “Size” field, click on “See all sizes” and select the D-Series v6 family of virtual machines. Select “D4ps_v6” from the list.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance.png "Figure 1: Select the D-Series v6 family of virtual machines")
+
+5. Select "SSH public key" as an Authentication type. Azure will automatically generate an SSH key pair for you and allow you to store it for future use. It is a fast, simple, and secure way to connect to your virtual machine.
+6. Fill in the Administrator username for your VM.
+7. Select "Generate new key pair", and select "RSA SSH Format" as the SSH Key Type. RSA could offer better security with keys longer than 3072 bits. Give a Key pair name to your SSH key.
+8. In the "Inbound port rules", select HTTP (80) and SSH (22) as the inbound ports.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance1.png "Figure 2: Allow inbound port rules")
+
+9. Click on the "Review + Create" tab and review the configuration for your virtual machine. It should look like the following:
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/ubuntu-pro.png "Figure 3: Review and Create an Azure Cobalt 100 Arm64 VM")
+
+10. Finally, when you are confident about your selection, click on the "Create" button, and click on the "Download Private Key and Create Resources" button.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance4.png "Figure 4: Download Private key and Create Resources")
+
+11. Your virtual machine should be ready and running within no time. You can SSH into the virtual machine using the private key, along with the Public IP details.
+
+![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/final-vm.png "Figure 5: VM deployment confirmation in Azure portal")
+
+{{% notice Note %}}
+
+To learn more about Arm-based virtual machines in Azure, refer to “Getting Started with Microsoft Azure” in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
+
+{{% /notice %}}
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/background.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/background.md
index 1d0e48dd02..1a5a3afe13 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/background.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/background.md
@@ -1,11 +1,17 @@
 ---
-title: Getting started with RabbitMQ on Google Axion C4A (Arm Neoverse-V2)
+title: Technology Stack Overview
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
+## Cobalt 100 Arm-based processor
+
+Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor: the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. These include web and application servers, data analytics, open-source databases, caching systems, and other related technologies. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
+
+To learn more about Cobalt 100, refer to the blog [Announcing the preview of new Azure virtual machine based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
+
 ## Google Axion C4A Arm instances in Google Cloud
 
 Google Axion C4A is a family of Arm-based virtual machines built on Google’s custom Axion CPU, which is based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, these virtual machines offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/baseline.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_baseline.md
similarity index 99%
rename from content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/baseline.md
rename to content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_baseline.md
index 9f6b66be5b..4a001c85b1 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/baseline.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_baseline.md
@@ -1,6 +1,6 @@
 ---
 title: RabbitMQ Baseline Testing on Google Axion C4A Arm Virtual Machine
-weight: 6
+weight: 9
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/firewall_setup.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_firewall_setup.md
similarity index 98%
rename from content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/firewall_setup.md
rename to content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_firewall_setup.md
index de6f9b7fa8..1898fc66d9 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/firewall_setup.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_firewall_setup.md
@@ -1,6 +1,6 @@
 ---
 title: Create a Firewall Rule on GCP
-weight: 3
+weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
@@ -33,4 +33,4 @@ Finally, select **Specified protocols and ports** under the **Protocols and port
 
 ![Specifying the TCP port to expose](images/network-port.png "Specifying the TCP port to expose")
 
-The network firewall rule is now created and you can continue with the VM creation.
\ No newline at end of file
+The network firewall rule is now created and you can continue with the VM creation.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/installation.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_installation.md
similarity index 98%
rename from content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/installation.md
rename to content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_installation.md
index e81746c810..6cc1836d35 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/installation.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_installation.md
@@ -1,6 +1,6 @@
 ---
-title: Install RabbitMQ
-weight: 5
+title: Install RabbitMQ on GCP SUSE Arm64 VM
+weight: 8
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
@@ -136,4 +136,4 @@ If everything is configured correctly, you see a RabbitMQ login page in your bro
 
 ![RabbitMQ page alt-text#center](images/rabbitmq.png "Figure 1: RabbitMQ Login page")
 
-This confirms that your RabbitMQ management dashboard is operational.
\ No newline at end of file
+This confirms that your RabbitMQ management dashboard is operational.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/instance.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_instance.md
similarity index 95%
rename from content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/instance.md
rename to content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_instance.md
index b284524b8d..d5b306c996 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/instance.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_instance.md
@@ -1,6 +1,6 @@
 ---
 title: Create a Google Axion C4A Arm virtual machine on GCP 
-weight: 4
+weight: 7
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
@@ -9,6 +9,7 @@ layout: learningpathall
 ## Overview
 
 In this section, you provision a Google Axion C4A Arm virtual machine on Google Cloud Platform (GCP) using the `c4a-standard-4` (4 vCPUs, 16 GB memory) machine type in the Google Cloud Console.  
+We will then use this GCP VM to execute a few RabbitMQ use cases.
 
 {{% notice Note %}}
 For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](https://learn.arm.com/learning-paths/servers-and-cloud-computing/csp/google/).
@@ -36,4 +37,4 @@ A window opens from your browser and you see a shell into your VM instance.
 
 ![Terminal Shell in your VM instance alt-text#center](images/gcp-shell.png "Terminal shell in your VM instance")
 
-Next, install RabbitMQ.
\ No newline at end of file
+Next, install RabbitMQ.
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case1.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case1.md
similarity index 99%
rename from content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case1.md
rename to content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case1.md
index 5ef1abeec8..cd59623083 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case1.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case1.md
@@ -1,6 +1,6 @@
 ---
 title: RabbitMQ Use Case 1 – Event Processing with Python Workers
-weight: 7
+weight: 10
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case2.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case2.md
similarity index 99%
rename from content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case2.md
rename to content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case2.md
index 9fbf674f90..e3067c4779 100644
--- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/use-case2.md
+++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/gcp_use_case2.md
@@ -1,6 +1,6 @@
 ---
 title: RabbitMQ use case 2 - WhatsApp Notification
-weight: 8 
+weight: 11 
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/final-vm.png b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/final-vm.png
new file mode 100644
index 0000000000..5207abfb41
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/final-vm.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance.png b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance.png
new file mode 100644
index 0000000000..285cd764a5
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance1.png b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance1.png
new file mode 100644
index 0000000000..b9d22c352d
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance1.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance4.png b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance4.png
new file mode 100644
index 0000000000..2a0ff1e3b0
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/instance4.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/ubuntu-pro.png b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/ubuntu-pro.png
new file mode 100644
index 0000000000..d54bd75ca6
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/images/ubuntu-pro.png differ