From aec4c029832873548e2ba61a802d2c248ce57e53 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Tue, 17 Jun 2025 10:22:00 +0000
Subject: [PATCH 01/16] Starting content review

---
 .../cobalt/1-create-cobalt-vm.md              |  9 ++++----
 .../cobalt/_index.md                          |  8 +++----
 style_suggestions.json                        | 23 +++++++++++++++++++
 3 files changed, 32 insertions(+), 8 deletions(-)
 create mode 100644 style_suggestions.json

diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
index 7c9f295138..9026d841ca 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
@@ -8,12 +8,13 @@ layout: learningpathall
 
 ## Use the Azure Portal to deploy a Cobalt 100 VM
 
-Cobalt 100 is Microsoft’s first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. The Cobalt 100 processor is optimized for the performance of scale-out cloud-based applications.
+Cobalt 100 is Microsoft’s first Arm-based server processor, built on the Armv9 Neoverse-N2 CPU architecture. It is optimized for the performance and efficiency of scale-out, cloud-based applications.
 
-The Azure Cobalt 100 VM instances include two series:
+Azure offers Cobalt 100–powered virtual machines in two series:
+
+- **Dpsv6** and **Dplsv6** (general-purpose)
+- **Epsv6** (memory-optimized)
 
-The general-purpose Dpsv6 and Dplsv6 virtual machine series.
-The memory-optimized Epsv6 virtual machine series.
 
 To create a Cobalt 100 VM, follow these steps:
 
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md
index 8ea17b5fbc..dad1d69ec9 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md
@@ -1,18 +1,18 @@
 ---
-title: Create an Azure Cobalt 100 VM
+title: Deploy a Cobalt 100 Virtual Machine on Azure
 
 minutes_to_complete: 10
 
-who_is_this_for: This is an introductory topic for developers and DevOps engineers who need an Arm-based virtual machine on Azure and want to expose an application port to the internet.
+who_is_this_for: This is an introductory topic for developers and DevOps engineers who want to deploy an Arm-based virtual machine on Azure and expose an application port to the internet.
 
 learning_objectives:
     - Deploy an Arm-based Cobalt 100 virtual machine (VM) on Microsoft Azure.
     - Connect to the Cobalt 100 VM using SSH.
-    - Open an inbound TCP port in the associated Network Security Group (NSG).
+    - Configure an inbound TCP port in the associated Network Security Group (NSG).
     - Verify external connectivity to the newly opened port.
 
 prerequisites:
-    - A Microsoft Azure subscription with permission to create resources
+    - A Microsoft Azure subscription with permissions to create virtual machines and networking resources
     - Basic familiarity with SSH
 
 author: Joe Stech
diff --git a/style_suggestions.json b/style_suggestions.json
new file mode 100644
index 0000000000..08e6abacca
--- /dev/null
+++ b/style_suggestions.json
@@ -0,0 +1,23 @@
+[
+  {
+    "file": "content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md",
+    "line": 11,
+    "original": "Cobalt 100 is Microsoft\u2019s first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. The Cobalt 100 processor is optimized for the performance of scale-out cloud-based applications.",
+    "suggested": "Cobalt 100 is Microsoft\u2019s first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. The Cobalt 100 processor is improved for the performance of scale-out cloud-based applications.",
+    "reason": "Simplify language by replacing 'optimized' with 'improved'."
+  },
+  {
+    "file": "content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md",
+    "line": 16,
+    "original": "The memory-optimized Epsv6 virtual machine series.",
+    "suggested": "The memory-improved Epsv6 virtual machine series.",
+    "reason": "Simplify language by replacing 'optimized' with 'improved'."
+  },
+  {
+    "file": "content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md",
+    "line": 24,
+    "original": "   The Dpsv6-series are powered by Cobalt 100. Selecting Standard_D4ps_v6 will give you a Cobalt VM with 4 physical cores. you can change the 4 to another value if you want a different number of cores.",
+    "suggested": "   The Dpsv6-Cobalt powered series 100. Selecting Standard_D4ps_v6 will give you a Cobalt VM with 4 physical cores. you can change the 4 to another value if you want a different number of cores.",
+    "reason": "Convert passive voice to active voice for clarity and directness."
+  }
+]
\ No newline at end of file

From 62f4e50aed842db33ab78bb7854ac2de582f7d36 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Tue, 17 Jun 2025 10:37:49 +0000
Subject: [PATCH 02/16] Further updates

---
 .../cobalt/1-create-cobalt-vm.md                          | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
index 9026d841ca..4044120a09 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
@@ -22,12 +22,12 @@ To create a Cobalt 100 VM, follow these steps:
 2. Select **Create a resource → Compute → Virtual machine**.
 3. Complete the *Basics* tab:
    ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png)
-   The Dpsv6-series are powered by Cobalt 100. Selecting Standard_D4ps_v6 will give you a Cobalt VM with 4 physical cores. you can change the 4 to another value if you want a different number of cores.
+   Cobalt 100 powers the Dpsv6-series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. You can select a different size if you need more or fewer cores.
 4. Upload your public SSH key or generate a new one in the wizard.
 5. Disallow public inbound ports for now.
-5. Accept the defaults on the *Disks* tab.
-6. On the *Networking* tab ensure that a **Public IP** is selected. You will need it to connect later. Leave the NSG settings as *Basic* for now. 
+6. Accept the defaults on the **Disks** tab.
+7. On the **Networking** tab ensure that a **Public IP** is selected. You will need it to connect later. Leave the NSG settings as **Basic** for now. 
 
 Click **Review + create** followed by **Create**. Azure now deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes.
 
-Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment succeeds proceed to the next step to expose an inbound port.
+Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment succeeds, proceed to the next step to expose an inbound port.

From bb030344aac70564e542715f5133dcebe915df7b Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Tue, 17 Jun 2025 10:55:30 +0000
Subject: [PATCH 03/16] Updates

---
 .../cobalt/1-create-cobalt-vm.md                       | 10 +++++-----
 .../servers-and-cloud-computing/cobalt/2-open-port.md  | 10 +++++-----
 .../servers-and-cloud-computing/cobalt/_index.md       |  8 ++++----
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
index 4044120a09..4ea4681d70 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
@@ -20,13 +20,13 @@ To create a Cobalt 100 VM, follow these steps:
 
 1. Sign in to the [Azure Portal](https://portal.azure.com/).
 2. Select **Create a resource → Compute → Virtual machine**.
-3. Complete the *Basics* tab:
-   ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png)
+3. Complete the **Basics** tab as shown in the figure below:
+   ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png "Configuring the Basics tab")
    Cobalt 100 powers the Dpsv6-series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. You can select a different size if you need more or fewer cores.
 4. Upload your public SSH key or generate a new one in the wizard.
-5. Disallow public inbound ports for now.
-6. Accept the defaults on the **Disks** tab.
-7. On the **Networking** tab ensure that a **Public IP** is selected. You will need it to connect later. Leave the NSG settings as **Basic** for now. 
+5. For **Public inbound ports**, select **None**.
+6. On the **Disks** tab, accept the default options.
+7. On the **Networking** tab, ensure that a **Public IP** is selected. You will need it to connect later. Leave the NSG settings as **Basic** for now. 
 
 Click **Review + create** followed by **Create**. Azure now deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes.
 
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
index e5ba4c890f..3f9bfcd2e5 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
@@ -1,5 +1,5 @@
 ---
-title: Open an inbound port in the Network Security Group
+title: Open inbound ports in the Network Security Group
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -8,16 +8,16 @@ layout: learningpathall
 
 ## Allow external traffic to TCP ports 22 (SSH) and 8080
 
-Every new virtual machine created through the Azure wizard is associated with a **Network Security Group (NSG)**. An NSG acts like a stateful firewall – if no rule explicitly allows traffic, Azure blocks it.
+Every new virtual machine created through the Azure wizard is associated with a **Network Security Group (NSG)**. An NSG acts as a stateful firewall – if no rule explicitly allows traffic, Azure blocks it by default.
 
 In this step you will open port 22 for SSH, as well as port 8080 so that a web application running on the VM is reachable from your IP for testing. Substitute a different port if required by your workload, or a different IP range if you'd like broader accessibility.
 
-1. In the Azure Portal open the newly created VM resource and click **Networking → Network settings** in the left nav.
+1. In the Azure Portal, open the newly created VM resource and click **Networking → Network settings** in the left nav.
 2. Select the **Network security group**.
-3. Click on **Create Port Rule** and from the drop-down men select **Inbound port rule**
+3. Click on **Create Port Rule** and from the drop-down menu select **Inbound port rule**
 4. Fill in the form, specifying **My IP address** as the source and 22 as the destination port:
    ![Add inbound security rule with source of my IP and destination port 22#center](images/create-nsg-rule.png)
 5. Click **Add**.
 To open port 8080, follow steps 3 through 5 again, but instead choose port 8080 for the destination port.
 
-You have now opened ports 22 and 8080 to your IP. In the next step you will verify connectivity.
+You have now opened ports 22 and 8080 to your IP. In the next step, you will verify connectivity.
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md
index dad1d69ec9..4cb83a8d31 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md
@@ -6,10 +6,10 @@ minutes_to_complete: 10
 who_is_this_for: This is an introductory topic for developers and DevOps engineers who want to deploy an Arm-based virtual machine on Azure and expose an application port to the internet.
 
 learning_objectives:
-    - Deploy an Arm-based Cobalt 100 virtual machine (VM) on Microsoft Azure.
-    - Connect to the Cobalt 100 VM using SSH.
-    - Configure an inbound TCP port in the associated Network Security Group (NSG).
-    - Verify external connectivity to the newly opened port.
+    - Deploy an Arm-based Cobalt 100 virtual machine (VM) on Microsoft Azure
+    - Connect to the Cobalt 100 VM using SSH
+    - Configure an inbound TCP port in the associated Network Security Group (NSG)
+    - Verify external connectivity to the newly-opened port
 
 prerequisites:
     - A Microsoft Azure subscription with permissions to create virtual machines and networking resources

From 4470ad6f69392bd9133bec3ad4f19637f03945e8 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Tue, 17 Jun 2025 13:34:44 +0000
Subject: [PATCH 04/16] Updates

---
 .../cobalt/1-create-cobalt-vm.md              | 15 ++++++++-----
 .../cobalt/2-open-port.md                     | 17 ++++++++------
 .../cobalt/3-verify-connectivity.md           | 22 ++++++++++---------
 3 files changed, 31 insertions(+), 23 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
index 4ea4681d70..af8b3b2cac 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
@@ -20,14 +20,17 @@ To create a Cobalt 100 VM, follow these steps:
 
 1. Sign in to the [Azure Portal](https://portal.azure.com/).
 2. Select **Create a resource → Compute → Virtual machine**.
-3. Complete the **Basics** tab as shown in the figure below:
+3. Complete the fields in the **Basics** tab with the values shown in the figure below:
+
    ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png "Configuring the Basics tab")
-   Cobalt 100 powers the Dpsv6-series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. You can select a different size if you need more or fewer cores.
+   
+   Cobalt 100 powers the Dpsv6-series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. 
+   You can choose a different size if you need more or fewer cores.
 4. Upload your public SSH key or generate a new one in the wizard.
-5. For **Public inbound ports**, select **None**.
+5. For the **Public inbound ports** field, select **None**.
 6. On the **Disks** tab, accept the default options.
-7. On the **Networking** tab, ensure that a **Public IP** is selected. You will need it to connect later. Leave the NSG settings as **Basic** for now. 
+7. On the **Networking** tab, ensure that a **Public IP** is selected. You will need it to connect to the VM later. Leave the NSG settings as **Basic**. 
 
-Click **Review + create** followed by **Create**. Azure now deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes.
+8. Select **Review + create**, then **Create**. Azure now deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes.
 
-Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment succeeds, proceed to the next step to expose an inbound port.
+9. Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment succeeds, proceed to the next step to expose an inbound port.
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
index 3f9bfcd2e5..19d776ddf9 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
@@ -10,14 +10,17 @@ layout: learningpathall
 
 Every new virtual machine created through the Azure wizard is associated with a **Network Security Group (NSG)**. An NSG acts as a stateful firewall – if no rule explicitly allows traffic, Azure blocks it by default.
 
-In this step you will open port 22 for SSH, as well as port 8080 so that a web application running on the VM is reachable from your IP for testing. Substitute a different port if required by your workload, or a different IP range if you'd like broader accessibility.
+In this step, you'll open port 22 for SSH and port 8080 so that a web application running on the VM is reachable from your IP for testing. Substitute a different port if required by your workload, or a different IP range if you'd like broader accessibility.
 
-1. In the Azure Portal, open the newly created VM resource and click **Networking → Network settings** in the left nav.
+1. In the Azure Portal, open the newly-created VM resource and select **Networking → Network settings** from the left-hand menu.
 2. Select the **Network security group**.
-3. Click on **Create Port Rule** and from the drop-down menu select **Inbound port rule**
-4. Fill in the form, specifying **My IP address** as the source and 22 as the destination port:
+3. Select **Create Port Rule**, then choose **Inbound port rule** from the drop-down menu.
+
+4. Fill in the form with **My IP address** as the source and 22 as the destination port:
+
    ![Add inbound security rule with source of my IP and destination port 22#center](images/create-nsg-rule.png)
-5. Click **Add**.
-To open port 8080, follow steps 3 through 5 again, but instead choose port 8080 for the destination port.
 
-You have now opened ports 22 and 8080 to your IP. In the next step, you will verify connectivity.
+5. Select **Add**.
+To open port 8080, repeat steps 3-5 and enter 8080 as the destination port.
+
+You have now opened ports 22 and 8080 to your IP. In the next step, you will verify connectivity from your local machine.
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md b/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md
index b16db0151c..d28242eb5f 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md
@@ -8,20 +8,20 @@ layout: learningpathall
 
 ## Connect over SSH and test the open port
 
-1. On the **Overview** page for the VM copy the **Public IP address**.
+1. On the **Overview** page of the VM, copy the **Public IP address**.
 2. Open a terminal on your local machine and SSH to the VM (replace *azureuser* if you chose a different admin username):
 
 ```bash
 ssh -i [path to your pem file] azureuser@[public IP]
 ```
 
-Where `[public IP]` is your public IP and `[path to your pem file]` is the path to your SSH key file.
+Replace `[public IP]` with your VM's public IP address, and `[path to your pem file]` with the path to your SSH private key file.
 
-Accept the prompt to add the host to *known_hosts* the first time you connect.
+When prompted, confirm the connection to add the VM to your *known_hosts* file.
 
-### Start a simple HTTP server
+### Start a temporary HTTP server
 
-If you do not already have an application listening on TCP 8080 you can start one temporarily:
+If you don't already have an application listening on TCP 8080, you can start one temporarily:
 
 ```bash
 sudo apt update -y && sudo apt install -y python3
@@ -32,16 +32,18 @@ Leave this terminal open – the server runs in the foreground.
 
 ### Test from your local machine
 
-In a second local terminal run `curl` to confirm you can reach the server through the NSG rule you created:
+In a second local terminal run `curl` to confirm that you can reach the server through the NSG rule you created:
 
 ```bash
 curl http://[public IP]:8080
 ```
 
-Where `[public IP]` is your public IP.
+Replace `[public IP]` with your VM's public IP address.
 
-You should see an HTML directory listing (or your application response). Receiving a response verifies that TCP 8080 is open and the VM is reachable from the public internet.
+You should see an HTML directory listing (or your application response). A successful response confirms that TCP port 8080 is open and the VM is reachable from the public internet.
 
-Terminate the Python server when you are finished testing (press `Ctrl + C`).
+To stop the server, press `Ctrl + C`.
 
-You now have an Arm-based Cobalt 100 VM with an exposed port 8080 that you can use to run any test server. To learn about optimizing .NET workloads on Cobalt, check out [Migrating a .NET application to Azure Cobalt](../../dotnet-migration/).
\ No newline at end of file
+You now have an Arm-based Cobalt 100 VM with port 8080 open and ready to receive external traffic. You can use it to run any test server or deploy your own application. 
+
+To learn about optimizing .NET workloads on Cobalt, check out [Migrating a .NET application to Azure Cobalt](../../dotnet-migration/).
\ No newline at end of file

From cf1d862c39aa5df32dd890d9e386e24dcba71d4a Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Tue, 17 Jun 2025 13:53:40 +0000
Subject: [PATCH 05/16] Updates

---
 .../cobalt/1-create-cobalt-vm.md                          | 8 ++++----
 .../servers-and-cloud-computing/cobalt/2-open-port.md     | 7 ++++---
 .../cobalt/3-verify-connectivity.md                       | 3 +--
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
index af8b3b2cac..1a10514dbb 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md
@@ -20,17 +20,17 @@ To create a Cobalt 100 VM, follow these steps:
 
 1. Sign in to the [Azure Portal](https://portal.azure.com/).
 2. Select **Create a resource → Compute → Virtual machine**.
-3. Complete the fields in the **Basics** tab with the values shown in the figure below:
+3. Complete the fields in the **Basics** tab using the values shown in the figure below:
 
    ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png "Configuring the Basics tab")
    
-   Cobalt 100 powers the Dpsv6-series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. 
+   Cobalt 100 powers the Dpsv6 and Dplsv6 series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. 
    You can choose a different size if you need more or fewer cores.
 4. Upload your public SSH key or generate a new one in the wizard.
 5. For the **Public inbound ports** field, select **None**.
 6. On the **Disks** tab, accept the default options.
 7. On the **Networking** tab, ensure that a **Public IP** is selected. You will need it to connect to the VM later. Leave the NSG settings as **Basic**. 
 
-8. Select **Review + create**, then **Create**. Azure now deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes.
+8. Select **Review + create**, then **Create**. Azure deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes.
 
-9. Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment succeeds, proceed to the next step to expose an inbound port.
+9. Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment completes, proceed to the next step to expose an inbound port.
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
index 19d776ddf9..7f9b44d24a 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md
@@ -18,9 +18,10 @@ In this step, you'll open port 22 for SSH and port 8080 so that a web applicatio
 
 4. Fill in the form with **My IP address** as the source and 22 as the destination port:
 
-   ![Add inbound security rule with source of my IP and destination port 22#center](images/create-nsg-rule.png)
+   ![Add inbound security rule with source of my IP and destination port 22#center](images/create-nsg-rule.png "Create Port Rule form")
 
 5. Select **Add**.
-To open port 8080, repeat steps 3-5 and enter 8080 as the destination port.
 
-You have now opened ports 22 and 8080 to your IP. In the next step, you will verify connectivity from your local machine.
+6. To open port 8080, repeat steps 3-5 and enter 8080 as the destination port.
+
+You have now opened ports 22 and 8080 to your IP. In the next step, you'll verify connectivity from your local machine.
diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md b/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md
index d28242eb5f..35de9b698e 100644
--- a/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md
+++ b/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md
@@ -8,8 +8,7 @@ layout: learningpathall
 
 ## Connect over SSH and test the open port
 
-1. On the **Overview** page of the VM, copy the **Public IP address**.
-2. Open a terminal on your local machine and SSH to the VM (replace *azureuser* if you chose a different admin username):
+On the **Overview** page of the VM, copy the **Public IP address**. Open a terminal on your local machine, and SSH to the VM (replace *azureuser* if you chose a different admin username):
 
 ```bash
 ssh -i [path to your pem file] azureuser@[public IP]

From ce0babfbfde58fabcdbd535d7968bb2f9068240b Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Tue, 17 Jun 2025 17:53:13 +0000
Subject: [PATCH 06/16] remove json file

---
 style_suggestions.json | 23 -----------------------
 1 file changed, 23 deletions(-)
 delete mode 100644 style_suggestions.json

diff --git a/style_suggestions.json b/style_suggestions.json
deleted file mode 100644
index 08e6abacca..0000000000
--- a/style_suggestions.json
+++ /dev/null
@@ -1,23 +0,0 @@
-[
-  {
-    "file": "content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md",
-    "line": 11,
-    "original": "Cobalt 100 is Microsoft\u2019s first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. The Cobalt 100 processor is optimized for the performance of scale-out cloud-based applications.",
-    "suggested": "Cobalt 100 is Microsoft\u2019s first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. The Cobalt 100 processor is improved for the performance of scale-out cloud-based applications.",
-    "reason": "Simplify language by replacing 'optimized' with 'improved'."
-  },
-  {
-    "file": "content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md",
-    "line": 16,
-    "original": "The memory-optimized Epsv6 virtual machine series.",
-    "suggested": "The memory-improved Epsv6 virtual machine series.",
-    "reason": "Simplify language by replacing 'optimized' with 'improved'."
-  },
-  {
-    "file": "content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md",
-    "line": 24,
-    "original": "   The Dpsv6-series are powered by Cobalt 100. Selecting Standard_D4ps_v6 will give you a Cobalt VM with 4 physical cores. you can change the 4 to another value if you want a different number of cores.",
-    "suggested": "   The Dpsv6-Cobalt powered series 100. Selecting Standard_D4ps_v6 will give you a Cobalt VM with 4 physical cores. you can change the 4 to another value if you want a different number of cores.",
-    "reason": "Convert passive voice to active voice for clarity and directness."
-  }
-]
\ No newline at end of file

From 0b1aa0faca9c48e7fe7690fd2ecad575b82c15a8 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 11:14:09 +0000
Subject: [PATCH 07/16] Updated URL to .NET docs

---
 .../servers-and-cloud-computing/dotnet-migration/_index.md      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index a48ec1bd13..87e2b4a0c6 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -36,7 +36,7 @@ further_reading:
         type: documentation
     - resource:
         title: .NET documentation
-        link: https://docs.microsoft.com/en-us/dotnet/
+        link: https://learn.microsoft.com/en-us/dotnet/
         type: documentation
 
 

From 7d6e23e74552c561f0ff397098cde4b4684dda2b Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 11:52:57 +0000
Subject: [PATCH 08/16] Updates

---
 .../dotnet-migration/1-create-orchardcore-app.md   | 12 ++++++------
 .../dotnet-migration/_index.md                     | 14 +++++++-------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
index 49b0b64571..575bad151d 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
@@ -1,18 +1,18 @@
 ---
-title: Create a basic OrchardCore application
+title: Build and Run an OrchardCore CMS App on Azure Cobalt
 weight: 2
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-# Create a basic OrchardCore application
+# Getting started with the OrchardCore App 
 
-In this section, you will learn how to create and compile a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, as an example of a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, which can be used to create content-driven websites.
+In this section, you'll build and run a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, which is a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, that's commonly used to create content-driven websites.
 
 ## Step 1: Set up your development environment
 
-1. Launch an Azure Cobalt instance running Ubuntu 24.04, and open port 8080 to the internet. For instructions on how to do this, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path.
+1. Launch an Azure Cobalt 100 instance running Ubuntu 24.04, and open port 8080 to the internet. For setup instructions, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path.
 
 2. **Install .NET SDK**:
 
@@ -23,13 +23,13 @@ sudo apt-get update
 sudo apt-get install -y dotnet-sdk-8.0
 ```
 
-3. **Verify installations**:
+3. Verify the installation:
 
 ```bash
 dotnet --version
 ```
 
-The output should look like:
+You should see output similar to:
 
 ```output
 8.0.117
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index 87e2b4a0c6..5101ef091b 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -1,18 +1,18 @@
 ---
-title: Migrate a .NET application to Microsoft Azure Cobalt 100
+title: Migrate a .NET application to Azure Cobalt 100
 
 minutes_to_complete: 25
 
-who_is_this_for: This is an advanced learning path for .NET developers who want to take advantage of the cost and performance benefits of Azure Cobalt processors.
+who_is_this_for: This is an advanced learning path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors.
 
 learning_objectives: 
-    - Create and compile a basic OrchardCore CMS application
-    - Add a simple C shared library to your .NET application
-    - Learn about anyCPU hardware agnostic builds
-    - Learn about performance of different .NET versions
+    - Build and run a basic OrchardCore CMS application
+    - Integrate a simple C shared library into a .NET application
+    - Configure architecture-agnostic builds using AnyCPU
+    - Evaluate the performance of different .NET versions
 
 prerequisites:
-    - A Microsoft Azure account
+    - A Microsoft Azure account with permissions to deploy virtual machines
 
 author: Joe Stech
 

From 3653ad58a32f3b4c012adf6522fca50d152ed006 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 12:21:46 +0000
Subject: [PATCH 09/16] Improvements

---
 .../1-create-orchardcore-app.md               | 26 +++++++++++--------
 .../2-add-shared-c-library.md                 |  5 +++-
 .../dotnet-migration/_index.md                |  3 +++
 3 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
index 575bad151d..66289b9ba9 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
@@ -14,7 +14,7 @@ In this section, you'll build and run a basic [OrchardCore](https://github.com/O
 
 1. Launch an Azure Cobalt 100 instance running Ubuntu 24.04, and open port 8080 to the internet. For setup instructions, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path.
 
-2. **Install .NET SDK**:
+2. Install .NET SDK:
 
 ```bash
 wget https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb
@@ -41,17 +41,17 @@ You should see output similar to:
 sudo apt install gcc g++ build-essential -y
 ```
 
-## Step 2: Install the OrchardCore Templates
+## Step 2: Install the OrchardCore templates
 
-To start building an OrchardCore application, you need to install the OrchardCore templates. Open your terminal and run the following command:
+Install the OrchardCore templates:
 
 ```bash
 dotnet new install OrchardCore.ProjectTemplates::2.1.7
 ```
 
-This command installs the OrchardCore project templates, which you will use to create a new application.
+This command installs the OrchardCore project templates you'll use to create a new OrchardCore application.
 
-The output will look like:
+Expected output:
 
 ```output
 Success: OrchardCore.ProjectTemplates::2.1.7 installed the following templates:
@@ -66,7 +66,7 @@ Orchard Core Theme        octheme      [C#]      Web/Orchard Core/CMS
 
 ## Step 3: Create a new OrchardCore application
 
-1. **Create a new project**: Use the `dotnet` CLI to create a new OrchardCore application.
+1. Create a new project using the `dotnet` CLI to create a new OrchardCore application:
 
 ```bash
 dotnet new occms -n MyOrchardCoreApp
@@ -74,7 +74,7 @@ dotnet new occms -n MyOrchardCoreApp
 
    This command creates a new OrchardCore CMS application in a directory named `MyOrchardCoreApp`.
 
-2. **Navigate to the project directory**:
+2. Navigate to the project directory:
 
 ```bash
 cd MyOrchardCoreApp
@@ -82,7 +82,7 @@ cd MyOrchardCoreApp
 
 ## Step 4: Run the OrchardCore application
 
-1. **Build the application**: Compile the application using the following command:
+1. Build the application: 
 
 ```bash
 dotnet build
@@ -103,14 +103,18 @@ Build succeeded.
 
 Time Elapsed 00:00:38.05
 ```
-2. **Run the application**: Start the application with:
+2. Run the application::
 
 ```bash
 dotnet run --urls http://0.0.0.0:8080
 ```
 
-3. **Access the application**: Open a web browser and navigate to `http://[instance IP]:8080` to see your OrchardCore application in action, where `[instance IP]` is the public IP of your Azure Cobalt instance.
+3. Access the application:
+
+In your browser, navigate to `http://[instance IP]:8080` to see your OrchardCore application in action, replacing `[instance IP]` with the public IP of your Azure Cobalt instance.
+
+4. Configure the application: 
 
-4. **Configure the application as a blog** In the resulting configuration page, 
+On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup.
 
 You have successfully created and run a basic OrchardCore CMS application. In the next sections, you will learn how to integrate a C shared library into your .NET application and explore performance optimizations for Arm architecture.
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
index 5a837d155d..52f9dd68ee 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
@@ -1,5 +1,5 @@
 ---
-title: Add a simple C shared library to your .NET OrchardCore application
+title: Integrate a C shared library in your .NET OrchardCore app (with Arm Build support)
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -49,6 +49,9 @@ public static class NativeMethods
     public static extern void Greet();
 }
 ```
+{{% notice Note %}}
+On Linux, `mylib` maps to `libmylib.so`. On other platforms, the naming convention differs.
+{{% /notice %}}
 
 2. Call the `Greet` method from your application. For example, you can add the following code to your main program `Program.cs` as shown:
 
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index 5101ef091b..30d2cb8042 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -13,6 +13,9 @@ learning_objectives:
 
 prerequisites:
     - A Microsoft Azure account with permissions to deploy virtual machines
+    - Basic knowledge of C and .NET
+    - GCC installed (Linux) or access to a cross-compiler
+    - OrchardCore application created using the .NET CLI or Visual Studio
 
 author: Joe Stech
 

From 552d39b92b7812924714f8899abc5d1d2962bd4f Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 12:23:19 +0000
Subject: [PATCH 10/16] Updates

---
 .../dotnet-migration/2-add-shared-c-library.md                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
index 52f9dd68ee..2332779a8f 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
@@ -118,4 +118,4 @@ aarch64-linux-gnu-gcc -mcpu=neoverse-n2 -O3 -shared -o libmylib.so -fPIC mylib.c
 
 The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD opimizations).
 
-In the next section, you will explore how to make your build architecture agnostic with the anyCPU feature.
+In the next section, you will explore how to make your native interop architecture-agnostic using the anyCPU feature and runtime dispatch strategies.

From aed137e0c1c085dde739c7e4572f46755f238606 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 20:33:32 +0000
Subject: [PATCH 11/16] Further enhancements

---
 .../1-create-orchardcore-app.md               | 46 +++++++++++--------
 .../2-add-shared-c-library.md                 | 35 +++++++-------
 2 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
index 66289b9ba9..85e499f7fc 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
@@ -1,20 +1,22 @@
 ---
-title: Build and Run an OrchardCore CMS App on Azure Cobalt
+title: Build and run an OrchardCore CMS app on Azure Cobalt
 weight: 2
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-# Getting started with the OrchardCore App 
+# Getting started with the OrchardCore app 
 
 In this section, you'll build and run a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, which is a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, that's commonly used to create content-driven websites.
 
-## Step 1: Set up your development environment
+## Set up your development environment
 
-1. Launch an Azure Cobalt 100 instance running Ubuntu 24.04, and open port 8080 to the internet. For setup instructions, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path.
+First, launch an Azure Cobalt 100 instance running Ubuntu 24.04, and open port 8080 to the internet. 
 
-2. Install .NET SDK:
+For setup instructions, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path.
+
+Next, install .NET SDK:
 
 ```bash
 wget https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb
@@ -23,25 +25,25 @@ sudo apt-get update
 sudo apt-get install -y dotnet-sdk-8.0
 ```
 
-3. Verify the installation:
+Verify the installation:
 
 ```bash
 dotnet --version
 ```
 
-You should see output similar to:
+You should then see output similar to:
 
 ```output
 8.0.117
 ```
 
-4. Install gcc for compiling your application:
+Install gcc for compiling your application:
 
 ```bash
 sudo apt install gcc g++ build-essential -y
 ```
 
-## Step 2: Install the OrchardCore templates
+## Install the OrchardCore templates
 
 Install the OrchardCore templates:
 
@@ -64,31 +66,31 @@ Orchard Core Mvc Web App  ocmvc        [C#]      Web/Orchard Core/Mvc
 Orchard Core Theme        octheme      [C#]      Web/Orchard Core/CMS
 ```
 
-## Step 3: Create a new OrchardCore application
+## Create a new OrchardCore application
 
-1. Create a new project using the `dotnet` CLI to create a new OrchardCore application:
+First, create a new project using the `dotnet` CLI to create a new OrchardCore application:
 
 ```bash
 dotnet new occms -n MyOrchardCoreApp
 ```
 
-   This command creates a new OrchardCore CMS application in a directory named `MyOrchardCoreApp`.
+This command creates a new OrchardCore CMS application in a directory named `MyOrchardCoreApp`.
 
-2. Navigate to the project directory:
+Now navigate to the project directory:
 
 ```bash
 cd MyOrchardCoreApp
 ```
 
-## Step 4: Run the OrchardCore application
+## Run the OrchardCore application
 
-1. Build the application: 
+Build the application: 
 
 ```bash
 dotnet build
 ```
 
-The output will look like:
+The output should look like:
 
 ```output
 MSBuild version 17.8.27+3ab07f0cf for .NET
@@ -103,18 +105,22 @@ Build succeeded.
 
 Time Elapsed 00:00:38.05
 ```
-2. Run the application::
+Run the application:
 
 ```bash
 dotnet run --urls http://0.0.0.0:8080
 ```
 
-3. Access the application:
+Access the application:
+
+* In your browser, navigate to `http://[instance IP]:8080` to see your OrchardCore application in action. 
 
-In your browser, navigate to `http://[instance IP]:8080` to see your OrchardCore application in action, replacing `[instance IP]` with the public IP of your Azure Cobalt instance.
+* Replace `[instance IP]` with your VM’s public IP address. You can find it in the Azure portal under the Networking tab of your virtual machine.
 
-4. Configure the application: 
+Configure the application: 
 
 On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup.
 
+## Summary and next steps
+
 You have successfully created and run a basic OrchardCore CMS application. In the next sections, you will learn how to integrate a C shared library into your .NET application and explore performance optimizations for Arm architecture.
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
index 2332779a8f..db6be73360 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
@@ -1,5 +1,5 @@
 ---
-title: Integrate a C shared library in your .NET OrchardCore app (with Arm Build support)
+title: Integrate a C shared library into your .NET OrchardCore app 
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -8,14 +8,13 @@ layout: learningpathall
 
 ## Introduction
 
-In this section, you will learn how to integrate a simple C shared library into your .NET OrchardCore application. This process involves creating a C library, compiling it, and then using it within your .NET application. This integration can help you leverage existing C code and libraries, enhancing the functionality and performance of your application.
+In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application. You’ll create the library, compile it, and call it from your .NET code. This allows you to reuse existing C code and improve performance by accessing native functionality.
 
+## Create a C shared library
 
-## Step 1: Create a C shared library
+First, create a simple C shared library that defines a function you’ll call from your .NET application.
 
-First, you need to create a simple C shared library. This library will contain a function that you will call from your .NET application.
-
-1. Create a new file named `mylib.c` with the following content:
+Create a new file named `mylib.c` with the following content:
 
 ```c
 #include <stdio.h>
@@ -25,7 +24,7 @@ void greet() {
 }
 ```
 
-2. Compile the C file into a shared library:
+Compile the C file into a shared library:
 
 ```bash
 gcc -shared -o libmylib.so -fPIC mylib.c
@@ -33,11 +32,11 @@ gcc -shared -o libmylib.so -fPIC mylib.c
 
    This will generate a shared library file (`libmylib.so`).
 
-## Step 2: Use the C library in your .NET application
+## Use the C library in your .NET application
 
 Now that you have a shared library, you can use it in your .NET application.
 
-1. In your OrchardCore application, create a new class file named `NativeMethods.cs`:
+In your OrchardCore application, create a new class file named `NativeMethods.cs`:
 
 ```csharp
 using System;
@@ -50,10 +49,10 @@ public static class NativeMethods
 }
 ```
 {{% notice Note %}}
-On Linux, `mylib` maps to `libmylib.so`. On other platforms, the naming convention differs.
+On Linux, the `DllImport("mylib")` attribute resolves to `libmylib.so`. On Windows, the runtime would look for `mylib.dll`, and on macOS, `libmylib.dylib`.
 {{% /notice %}}
 
-2. Call the `Greet` method from your application. For example, you can add the following code to your main program `Program.cs` as shown:
+Call the `Greet` method from your application. For example, you can add the following code to your main program `Program.cs` as shown:
 
 ```csharp
 using OrchardCore.Logging;
@@ -91,31 +90,29 @@ app.UseOrchardCore();
 app.Run();
 ```
 
-3. Ensure that dotnet can find your shared library:
+Ensure that dotnet can find your shared library:
 
 ```bash
 export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH
 ```
 
-## Step 3: Run your application
+## Run your application
 
-Now when you run `dotnet run`, you will see
+When you run `dotnet run`, you’ll see the following output:
 
 ```bash
 Calling native greet...
 Hello from the C library!
 ```
 
-in the logging output.
-
 ## Compiling for Arm
 
-If you are compiling for Arm directly on Azure Cobalt, the compiler understands what default processor optimizations it should use, and you can compile as done in Step 1 above. However, if you are cross-compiling in your build pipeline, you should specify `-mcpu=neoverse-n2 -O3` when running the cross-compiler:
+If you are compiling for Arm directly on Azure Cobalt, the compiler understands what default processor optimizations it should use, and you can compile as done above. However, if you are cross-compiling in your build pipeline, you should specify `-mcpu=neoverse-n2 -O3` when running the cross-compiler:
 
 ```bash
 aarch64-linux-gnu-gcc -mcpu=neoverse-n2 -O3 -shared -o libmylib.so -fPIC mylib.c
 ```
 
-The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD opimizations).
+The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD optimizations).
 
-In the next section, you will explore how to make your native interop architecture-agnostic using the anyCPU feature and runtime dispatch strategies.
+In the next section, you’ll make your native interop cross-platform by using the `anyCPU` feature and runtime dispatch strategies.

From e4ce03da4fff4e51e47a5e90a3f9f05bb8af6098 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 21:36:23 +0000
Subject: [PATCH 12/16] Updates

---
 .../dotnet-migration/2-add-shared-c-library.md                 | 2 +-
 .../servers-and-cloud-computing/dotnet-migration/_index.md     | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
index db6be73360..bf06ba4ade 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
@@ -30,7 +30,7 @@ Compile the C file into a shared library:
 gcc -shared -o libmylib.so -fPIC mylib.c
 ```
 
-   This will generate a shared library file (`libmylib.so`).
+This creates a shared object file named `libmylib.so` which your .NET application can call at runtime.
 
 ## Use the C library in your .NET application
 
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index 587577f1a4..21b8e6c304 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -17,7 +17,8 @@ learning_objectives:
 
 prerequisites:
     - A Microsoft Azure account with permissions to deploy virtual machines
-    - Basic knowledge of C and .NET
+    - .NET SDK 8.0 or later 
+    - Basic knowledge of C and C#
     - GCC installed (Linux) or access to a cross-compiler
     - OrchardCore application created using the .NET CLI or Visual Studio
 

From 30ca2a8d2cf3f62d10147a70bdf64261cd08c8b6 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Wed, 18 Jun 2025 21:57:11 +0000
Subject: [PATCH 13/16] Updates

---
 .../dotnet-migration/3-any-cpu.md             | 25 ++++++++++---------
 .../dotnet-migration/4-dotnet-versions.md     |  4 +--
 .../dotnet-migration/_index.md                |  5 +---
 3 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md
index e109a8a51a..b1594605de 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md
@@ -6,18 +6,19 @@ weight: 4
 layout: learningpathall
 ---
 
-# Run a .NET OrchardCore application on Arm and x86
+## Run a .NET OrchardCore application on Arm and x86
 
-In this section, you will learn how to configure and run your OrchardCore application on both Arm and x86 architectures using the .NET AnyCPU configuration. This approach allows your application to be architecture agnostic, providing flexibility and ease of deployment across different hardware platforms.
+In this section, you will learn how to configure and run your OrchardCore application on both Arm and x86 architectures using the .NET AnyCPU configuration. This approach allows your application to be architecture-agnostic, enabling easier deployment across different hardware platforms.
 
-The AnyCPU feature has been around since .NET 2, but it's current incarnation was released in .NET Framework 4.5.
+The AnyCPU feature has existed since .NET Framework 2.0, but its current behavior (particularly how it handles 32-bit vs. 64-bit execution) was defined in .NET Framework 4.5.
 
 ## Configure the project for AnyCPU
 
-To make your OrchardCore application architecture agnostic, you need to configure it to use the AnyCPU platform target. This allows the .NET runtime to choose the appropriate architecture at runtime.
+To make your OrchardCore application architecture-agnostic, you need to configure it to use the AnyCPU platform target. This allows the .NET runtime to choose the appropriate architecture at runtime.
 
-1. Open your OrchardCore project `MyOrchardCoreApp.csproj` in your preferred IDE.
-2. Find the `<PropertyGroup>` and add the `<PlatformTarget>` element to `AnyCPU`:
+First, open your OrchardCore project `MyOrchardCoreApp.csproj` in your preferred IDE.
+
+Next, find the `<PropertyGroup>` and add the `<PlatformTarget>` element to `AnyCPU`:
 
 ```xml
 <PropertyGroup>
@@ -25,31 +26,31 @@ To make your OrchardCore application architecture agnostic, you need to configur
 </PropertyGroup>
 ```
 
-4. Save the changes to the `.csproj` file.
+Save the `.csproj` file:
 
 ## Build once, run anywhere
 
-You can now build your application on either an x86 or Arm host machine and deploy it on any architecture. 
+You can now build your application on either an x86 or Arm host machine and deploy it on any architecture:
 
 ```bash
 dotnet build -c Release
 ```
 
-4. Run the application:
+Run the application:
 
 ```bash
 dotnet run --urls http://0.0.0.0:8080
 ```
 
-Your application should now be runnable on any architecture. All you have to do is copy the `MyOrchardCoreApp` directory to any computer with the .NET 8 Framework installed and run the command shown from within the `MyOrchardCoreApp` directory:
+Your application should now be runnable on any architecture. All you have to do is copy the `MyOrchardCoreApp` directory to any computer with the .NET 8 runtime installed and run the command shown from within the `MyOrchardCoreApp` directory:
 
 ```bash
 dotnet ./bin/Release/net8.0/MyOrchardCoreApp.dll --urls http://0.0.0.0:8080
 ```
 
-## Benefits of architecture agnostic applications
+## Benefits of architecture-agnostic applications
 
-By configuring your application to be architecture agnostic, you gain several benefits:
+By configuring your application to be architecture-agnostic, you gain several benefits:
 
 - **Flexibility**: Deploy your application on a wide range of devices without modification.
 - **Efficiency**: Reduce the need for maintaining separate builds for different architectures.
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md
index 3e0d49d6eb..25fc5947e1 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md
@@ -1,12 +1,12 @@
 ---
-title: Evaluate .NET versions for performance on Arm
+title: Evaluate .NET performance across versions on Arm
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-# Evaluate .NET versions for performance on Arm
+## Evaluate .NET versions for performance on Arm
 
 Understanding which versions perform best and the features they offer can help you make informed decisions when developing applications for Arm-based systems.
 
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index 21b8e6c304..3187178011 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -1,10 +1,7 @@
 ---
 title: Migrate a .NET application to Azure Cobalt 100
 
-draft: true
-cascade:
-    draft: true
-    
+  
 minutes_to_complete: 25
 
 who_is_this_for: This is an advanced learning path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors.

From 88033cb47ec21777a7aad4fd0bf528e6a6f69f42 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Thu, 19 Jun 2025 09:24:28 +0000
Subject: [PATCH 14/16] Updates

---
 .../dotnet-migration/3-any-cpu.md             | 32 +++++++++++--------
 .../dotnet-migration/_index.md                |  4 +++
 2 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md
index b1594605de..48cba9c9fa 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md
@@ -1,5 +1,5 @@
 ---
-title: Run a .NET OrchardCore application on Arm and x86
+title: Configure and run an architecture-agnostic OrchardCore app on Arm and x86 using .NET AnyCPU
 weight: 4
 
 ### FIXED, DO NOT MODIFY
@@ -8,17 +8,21 @@ layout: learningpathall
 
 ## Run a .NET OrchardCore application on Arm and x86
 
-In this section, you will learn how to configure and run your OrchardCore application on both Arm and x86 architectures using the .NET AnyCPU configuration. This approach allows your application to be architecture-agnostic, enabling easier deployment across different hardware platforms.
+In this section, you will configure and run your OrchardCore application on both Arm and x86 architectures using .NET's AnyCPU configuration. This architecture-agnostic approach simplifies deployment and ensures that your application runs smoothly on diverse hardware, including cloud VMs, local development boxes, and edge devices.
 
-The AnyCPU feature has existed since .NET Framework 2.0, but its current behavior (particularly how it handles 32-bit vs. 64-bit execution) was defined in .NET Framework 4.5.
+The AnyCPU feature has existed since .NET Framework 2.0, but its current behavior (particularly how it handles 32-bit vs. 64-bit execution) was defined in .NET Framework 4.5. 
+
+{{% notice Note %}}
+In .NET Core and .NET 5+, AnyCPU still lets the runtime decide which architecture to use, but keep in mind that your build must match the runtime environment's bitness (32-bit vs. 64-bit). Since .NET 8 targets 64-bit by default, this Learning Path assumes 64-bit runtime environments on both Arm64 and x86_64.
+{{% /notice %}}
 
 ## Configure the project for AnyCPU
 
-To make your OrchardCore application architecture-agnostic, you need to configure it to use the AnyCPU platform target. This allows the .NET runtime to choose the appropriate architecture at runtime.
+To make your OrchardCore application architecture-agnostic, configure the project to use the AnyCPU platform target. This allows the .NET runtime to select the appropriate architecture at runtime.
 
-First, open your OrchardCore project `MyOrchardCoreApp.csproj` in your preferred IDE.
+1. Open your OrchardCore project `MyOrchardCoreApp.csproj` in your IDE.
 
-Next, find the `<PropertyGroup>` and add the `<PlatformTarget>` element to `AnyCPU`:
+2. Add the `<PlatformTarget>` element to your existing `<PropertyGroup>`:
 
 ```xml
 <PropertyGroup>
@@ -26,11 +30,13 @@ Next, find the `<PropertyGroup>` and add the `<PlatformTarget>` element to `AnyC
 </PropertyGroup>
 ```
 
-Save the `.csproj` file:
+3. Save the `.csproj` file.
+
+## Build and run on any platform
 
-## Build once, run anywhere
+You can now build your application once and run it on either an x86_64 or Arm64 system.
 
-You can now build your application on either an x86 or Arm host machine and deploy it on any architecture:
+Build the application:
 
 ```bash
 dotnet build -c Release
@@ -50,10 +56,10 @@ dotnet ./bin/Release/net8.0/MyOrchardCoreApp.dll --urls http://0.0.0.0:8080
 
 ## Benefits of architecture-agnostic applications
 
-By configuring your application to be architecture-agnostic, you gain several benefits:
+Using the AnyCPU configuration offers several advantages:
 
-- **Flexibility**: Deploy your application on a wide range of devices without modification.
-- **Efficiency**: Reduce the need for maintaining separate builds for different architectures.
+- **Flexibility**: Deploy your application on a wide range of devices without modifying your code.
+- **Efficiency**: Eliminate the need to maintain separate builds for different architectures.
 - **Scalability**: Easily scale your application across different hardware platforms.
 
-This approach ensures that your OrchardCore application can run seamlessly on both Arm and x86 architectures.
+This approach ensures that your OrchardCore application runs consistently on both Arm and x86 architectures.
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index 3187178011..32012f4a94 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -38,6 +38,10 @@ further_reading:
     - resource:
         title: OrchardCore documentation
         link: https://docs.orchardcore.net/
+        type: documentation  
+    - resource:
+        title: OrchardCore GitHub Repository
+        link: https://github.com/OrchardCMS/OrchardCore
         type: documentation
     - resource:
         title: .NET documentation

From 8a334c8dbe76eb8f4a44c02a905fe4870625ace0 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Thu, 19 Jun 2025 10:25:45 +0000
Subject: [PATCH 15/16] Updates

---
 .../dotnet-migration/1-create-orchardcore-app.md           | 4 ++--
 .../dotnet-migration/2-add-shared-c-library.md             | 7 ++-----
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
index 85e499f7fc..5e38939c6e 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
@@ -1,5 +1,5 @@
 ---
-title: Build and run an OrchardCore CMS app on Azure Cobalt
+title: Build and run an OrchardCore CMS app on Azure Cobalt (Arm64)
 weight: 2
 
 ### FIXED, DO NOT MODIFY
@@ -12,7 +12,7 @@ In this section, you'll build and run a basic [OrchardCore](https://github.com/O
 
 ## Set up your development environment
 
-First, launch an Azure Cobalt 100 instance running Ubuntu 24.04, and open port 8080 to the internet. 
+First, launch an Azure Cobalt 100 instance (Arm-based VM) running Ubuntu 24.04, and open port 8080 to the internet. 
 
 For setup instructions, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path.
 
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
index bf06ba4ade..699c888d53 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
@@ -5,13 +5,10 @@ weight: 3
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
-
-## Introduction
+## Create a C shared library
 
 In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application. You’ll create the library, compile it, and call it from your .NET code. This allows you to reuse existing C code and improve performance by accessing native functionality.
 
-## Create a C shared library
-
 First, create a simple C shared library that defines a function you’ll call from your .NET application.
 
 Create a new file named `mylib.c` with the following content:
@@ -115,4 +112,4 @@ aarch64-linux-gnu-gcc -mcpu=neoverse-n2 -O3 -shared -o libmylib.so -fPIC mylib.c
 
 The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD optimizations).
 
-In the next section, you’ll make your native interop cross-platform by using the `anyCPU` feature and runtime dispatch strategies.
+In the next section, you’ll make your native interop cross-platform by using the AnyCPU feature and runtime dispatch strategies.

From 4d88dde240bf2ee216ebe2948cd4f47a4df3ab74 Mon Sep 17 00:00:00 2001
From: Maddy Underwood <167196745+madeline-underwood@users.noreply.github.com>
Date: Thu, 19 Jun 2025 10:51:50 +0000
Subject: [PATCH 16/16] Final tweaks

---
 .../1-create-orchardcore-app.md               | 16 +++++-----
 .../2-add-shared-c-library.md                 | 10 +++++--
 .../dotnet-migration/4-dotnet-versions.md     | 29 ++++++++++++++-----
 .../dotnet-migration/_index.md                |  2 +-
 4 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
index 5e38939c6e..a25f47775f 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md
@@ -6,11 +6,11 @@ weight: 2
 layout: learningpathall
 ---
 
-# Getting started with the OrchardCore app 
+## Getting started with the OrchardCore app 
 
 In this section, you'll build and run a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, which is a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, that's commonly used to create content-driven websites.
 
-## Set up your development environment
+### Set up your development environment
 
 First, launch an Azure Cobalt 100 instance (Arm-based VM) running Ubuntu 24.04, and open port 8080 to the internet. 
 
@@ -43,7 +43,7 @@ Install gcc for compiling your application:
 sudo apt install gcc g++ build-essential -y
 ```
 
-## Install the OrchardCore templates
+### Install the OrchardCore templates
 
 Install the OrchardCore templates:
 
@@ -66,7 +66,7 @@ Orchard Core Mvc Web App  ocmvc        [C#]      Web/Orchard Core/Mvc
 Orchard Core Theme        octheme      [C#]      Web/Orchard Core/CMS
 ```
 
-## Create a new OrchardCore application
+### Create a new OrchardCore application
 
 First, create a new project using the `dotnet` CLI to create a new OrchardCore application:
 
@@ -82,7 +82,7 @@ Now navigate to the project directory:
 cd MyOrchardCoreApp
 ```
 
-## Run the OrchardCore application
+### Run the OrchardCore application
 
 Build the application: 
 
@@ -115,12 +115,12 @@ Access the application:
 
 * In your browser, navigate to `http://[instance IP]:8080` to see your OrchardCore application in action. 
 
-* Replace `[instance IP]` with your VM’s public IP address. You can find it in the Azure portal under the Networking tab of your virtual machine.
+* Replace `[instance IP]` with your VM’s public IP address. You can find it in the Azure portal under the **Networking** tab of your virtual machine.
 
 Configure the application: 
 
-On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup.
+* On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup.
 
-## Summary and next steps
+### Summary and next steps
 
 You have successfully created and run a basic OrchardCore CMS application. In the next sections, you will learn how to integrate a C shared library into your .NET application and explore performance optimizations for Arm architecture.
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
index 699c888d53..1cfd82b524 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md
@@ -7,11 +7,15 @@ layout: learningpathall
 ---
 ## Create a C shared library
 
-In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application. You’ll create the library, compile it, and call it from your .NET code. This allows you to reuse existing C code and improve performance by accessing native functionality.
+In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application, by doing the following:
 
-First, create a simple C shared library that defines a function you’ll call from your .NET application.
+- Write a C function
+- Compile it into a shared object (`.so`)
+- Call it from C# using `DllImport`
 
-Create a new file named `mylib.c` with the following content:
+This allows you to reuse existing C code and improve performance by accessing native functionality.
+
+Create a file named `mylib.c` with the following:
 
 ```c
 #include <stdio.h>
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md
index 25fc5947e1..7dcd881edb 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md
@@ -6,15 +6,26 @@ weight: 5
 layout: learningpathall
 ---
 
-## Evaluate .NET versions for performance on Arm
+## Version-by-version feature and throughput improvements
 
 Understanding which versions perform best and the features they offer can help you make informed decisions when developing applications for Arm-based systems.
 
 .NET has evolved significantly over the years, with each version introducing new features and performance improvements. Here, you will learn about key versions that have notable performance implications for Arm architecture.
 
+{{% notice Support status summary %}}
+
+- .NET 8 – Current LTS (support until Nov 2026)
+- .NET 9 – STS (preview; GA Q4 2025)
+- .NET 10 – Next LTS (preview; expected 2025 Q4–Q1 2026)
+- .NET 3.1, 5, 6, 7 – End of life
+{{% /notice %}}
+
+
 ## .NET Core 3.1 (end-of-life 2022)
 
-.NET Core 3.1 was the first LTS with meaningful Arm64 support. Highlights were:
+.NET Core 3.1 was the first LTS with meaningful Arm64 support. 
+
+Highlights were:
 
 - Initial JIT (Just-In-Time) optimizations for Arm64 (but the bulk of Arm throughput work arrived in .NET 5).
 - Faster garbage collection thanks to refinements to the background GC mode.
@@ -39,7 +50,9 @@ With .NET 5 Microsoft started the “one .NET” unification. Even though it had
 
 ## .NET 7 (end-of-life 2024)
 
-.NET 7 was an STS (Standard-Term Support) release which is now out of support, but it pushed the performance envelope and is therefore interesting from a historical perspective. Key highlights were:
+.NET 7 was an STS (Standard-Term Support) release which is now out of support, but it pushed the performance envelope and is therefore interesting from a historical perspective. 
+
+Key highlights were:
 
 - General-availability of Native AOT publishing for console applications, producing self-contained, very small binaries with fast start-up on Arm64.
 - Dynamic PGO (Profile-Guided Optimisation) and On-Stack Replacement became the default, letting the JIT optimise the hottest code paths based on real run-time data.
@@ -47,10 +60,12 @@ With .NET 5 Microsoft started the “one .NET” unification. Even though it had
 
 ## .NET 8 (current LTS – support until November 2026)
 
-.NET 8 is the current Long-Term Support release and should be your baseline for new production workloads. Important Arm-related improvements include:
+.NET 8 is the current Long-Term Support release and should be your baseline for new production workloads. 
+
+Important Arm-related improvements include:
 
 - Native AOT support for ASP.NET Core, trimming enhancements and even smaller self-contained binaries, translating into faster cold-start for containerised Arm services.
-- Further JIT tuning for Arm64 delivering single- to low-double-digit percentage throughput wins in real-world benchmarks.
+- Further JIT tuning for Arm64 delivering single-digit to low double-digit throughput gains in real-world benchmarks.
 - Smaller base container images (`mcr.microsoft.com/dotnet/aspnet:8.0` and `…/runtime:8.0`) thanks to a redesigned layering strategy, particularly beneficial on Arm where network bandwidth is often at a premium.
 - Garbage-collector refinements that reduce pause times on highly-threaded, many-core servers.
 
@@ -66,10 +81,10 @@ Although .NET 9 will receive only 18 months of support, it is an excellent choic
 
 ## .NET 10 (preview – next LTS)
 
-.NET 10 is still in preview and will likely change prior to it's GA release, but it will be the next LTS version of .NET.
+.NET 10 is still in preview and will likely evolve prior to its GA release, but it will be the next LTS version of .NET, with the following benefits:
 
 - [Extended SVE2 intrinsics](https://github.com/dotnet/runtime/issues/109652) to unlock efficient implementation of large-scale numerical algorithms and on-device AI inference on Arm v9.
 - C# 14 is expected to ship alongside .NET 10, bringing additional compile-time metaprogramming features that can reduce boilerplate on resource-constrained Arm edge devices.
 
-Because .NET 10 is still in preview, you should validate any assumptions about feature availability against the latest preview builds and roadmap updates.
+Developers targeting Arm-based systems should track preview builds and roadmap updates closely to validate feature availability and compatibility with their target platforms.
 
diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
index 32012f4a94..f7c657054b 100644
--- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
+++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md
@@ -4,7 +4,7 @@ title: Migrate a .NET application to Azure Cobalt 100
   
 minutes_to_complete: 25
 
-who_is_this_for: This is an advanced learning path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors.
+who_is_this_for: This is an advanced topic path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors.
 
 learning_objectives: 
     - Build and run a basic OrchardCore CMS application