diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md
new file mode 100644
index 0000000000..467205cda0
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md
@@ -0,0 +1,59 @@
+---
+title: Deploy Golang on the Microsoft Azure Cobalt 100 processors
+
+draft: true
+cascade:
+ draft: true
+
+minutes_to_complete: 40
+
+who_is_this_for: This Learning Path is designed for software developers looking to migrate their Golang workloads from x86_64 to Arm-based platforms, specifically on the Microsoft Azure Cobalt 100 processors.
+
+learning_objectives:
+ - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu Pro 24.04 LTS as the base image.
+ - Deploy Golang on an Arm64-based virtual machine running Ubuntu Pro 24.04 LTS.
+ - Perform Golang baseline testing and benchmarking on both x86_64 and Arm64 virtual machine.
+
+prerequisites:
+ - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6)
+ - Basic understanding of Linux command line.
+ - Familiarity with the [Golang](https://go.dev/) and deployment practices on Arm64 platforms.
+
+author: Jason Andrews
+
+### Tags
+skilllevels: Advanced
+subjects: Performance and Architecture
+cloud_service_providers: Microsoft Azure
+
+armips:
+ - Neoverse
+
+tools_software_languages:
+ - Golang
+ - go test -bench
+
+operatingsystems:
+ - Linux
+
+further_reading:
+ - resource:
+ title: Effective Go Benchmarking
+ link: https://go.dev/doc/effective_go#testing
+ type: Guide
+ - resource:
+ title: Testing and Benchmarking in Go
+ link: https://pkg.go.dev/testing
+ type: Official Documentation
+ - resource:
+ title: Using go test -bench for Benchmarking
+ link: https://pkg.go.dev/cmd/go#hdr-Testing_flags
+ type: Reference
+
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1 # _index.md always has weight of 1 to order correctly
+layout: "learningpathall" # All files under learning paths have this same wrapper
+learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
+---
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_next-steps.md
new file mode 100644
index 0000000000..c3db0de5a2
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_next-steps.md
@@ -0,0 +1,8 @@
+---
+# ================================================================================
+# FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21 # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps" # Always the same, html page title.
+layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing.
+---
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md
new file mode 100644
index 0000000000..4ad80dac05
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md
@@ -0,0 +1,18 @@
+---
+title: "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 more. 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).
+
+## Golang
+Golang (or Go) is an open-source programming language developed by Google, designed for simplicity, efficiency, and scalability. It provides built-in support for concurrency, strong typing, and a rich standard library, making it ideal for building reliable, high-performance applications.
+
+Go is widely used for cloud-native development, microservices, system programming, DevOps tools, and distributed systems. Learn more from the [Go official website](https://go.dev/) and its [official documentation](https://go.dev/doc/).
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md
new file mode 100644
index 0000000000..c71870f584
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md
@@ -0,0 +1,161 @@
+---
+title: Golang Baseline Testing
+weight: 5
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+
+### Baseline testing of Golang Web Page on Azure Arm64
+This section demonstrates how to test your Go installation on the **Ubuntu Pro 24.04 LTS Arm64** virtual machine by creating and running a simple Go web server that serves a styled HTML page.
+
+**1. Create Project Directory**
+
+First, create a new folder called goweb to contain all project files, and then navigate into it:
+
+```console
+mkdir goweb && cd goweb
+```
+This command creates a new directory named goweb and then switches into it.
+
+**2. Create HTML Page with Bootstrap Styling**
+
+Next, create a file named `index.html` using the nano editor:
+
+```console
+nano index.html
+```
+
+Paste the following HTML code into the index.html file. This builds a simple, styled web page with a header, a welcome message, and a button using Bootstrap.
+
+```html
+
+
+
+
+
+ Go Web on Azure ARM64
+
+
+
+
+
+
+
Go Web on Azure Arm64
+
This page is powered by Golang running on the Microsoft Azure Cobalt 100 processors.
+
+
+```
+**3. Create Golang Web Server**
+
+Now create the Go program that will serve this web page:
+
+```console
+nano main.go
+```
+Paste the following code into the main.go file. This sets up a very basic web server that serves files from the current folder, including the **index.html** you just created. When it runs, it will print a message showing the server address.
+
+```go
+package main
+import (
+ "encoding/json"
+ "log"
+ "net/http"
+ "time"
+)
+func main() {
+ // Serve index.html for root
+ http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path == "/" {
+ http.ServeFile(w, r, "index.html")
+ return
+ }
+ http.FileServer(http.Dir(".")).ServeHTTP(w, r)
+ })
+ // REST API endpoint for JSON response
+ http.HandleFunc("/api/hello", func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ json.NewEncoder(w).Encode(map[string]string{
+ "message": "Hello from Go on Azure ARM64!",
+ "time": time.Now().Format(time.RFC1123),
+ })
+ })
+ log.Println("Server running on http://0.0.0.0:80")
+ log.Fatal(http.ListenAndServe(":80", nil))
+}
+```
+{{% notice Note %}}Running on port 80 requires root privileges. Use sudo with the full Go path if needed.{{% /notice %}}
+**4. Run on the Web Server**
+
+Run your Go program with:
+
+```console
+sudo /usr/local/go/bin/go run main.go
+```
+
+This compiles and immediately starts the server. If the server starts successfully, you will see the following message in your terminal::
+
+```output
+2025/08/19 04:35:06 Server running on http://0.0.0.0:80
+```
+**5. Allow HTTP Traffic in Firewall**
+
+On **Ubuntu Pro 24.04 LTS** virtual machines, **UFW (Uncomplicated Firewall)** is used to manage firewall rules. By default, it allows only SSH (port 22) and blocks most other traffic.
+
+So even if Azure allows HTTP on port 80 (added to inbound ports during VM creation), your VM’s firewall may still block it until you run:
+
+```console
+sudo ufw allow 80/tcp
+sudo ufw enable
+```
+You can verify that HTTP is now allowed with:
+
+```console
+sudo ufw status
+```
+You should see an output similar to:
+```output
+Status: active
+
+To Action From
+-- ------ ----
+8080/tcp ALLOW Anywhere
+80/tcp ALLOW Anywhere
+8080/tcp (v6) ALLOW Anywhere (v6)
+80/tcp (v6) ALLOW Anywhere (v6)
+```
+
+**6. Open in Browser**
+
+Run the following command to print your VM’s public URL, then open it in a browser:
+
+```console
+echo "http://$(curl -s ifconfig.me)/"
+```
+When you visit this link, you should see the styled HTML page being served directly by your Go application.
+
+You should see the Golang web page confirming a successful installation of Golang.
+
+
+
+Now, your Golang instance is ready for further benchmarking and production use.
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/benchmarking.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/benchmarking.md
new file mode 100644
index 0000000000..9408bdf6db
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/benchmarking.md
@@ -0,0 +1,203 @@
+---
+title: Benchmarking via go test -bench
+weight: 6
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Run the performance tests using go test -bench
+
+`go test -bench` (the benchmarking mode of go test) is Golang’s built-in benchmarking framework that measures the performance of functions by running them repeatedly and reporting execution time (**ns/op**), memory usage, and allocations. With the `-benchmem flag`, it also shows memory usage and allocations. It’s simple, reliable, and requires only writing benchmark functions in the standard Golang testing package.
+
+1. Create a Project Folder
+
+Open your terminal and create a new folder for this project:
+
+```console
+mkdir gosort-bench
+cd gosort-bench
+```
+
+2. Initialize a Go Module
+
+Inside the project directory, run following command:
+
+```console
+go mod init gosort-bench
+```
+This creates a go.mod file, which defines the module path (gosort-bench in this case) and marks the directory as a Go project. The go.mod file also allows Go to manage dependencies (external libraries) automatically, ensuring your project remains reproducible and easy to maintain.
+
+3. Add Sorting Functions
+
+Create a file called **sorting.go**:
+
+```console
+nano sorting.go
+```
+Paste this code in **sorting.go** file:
+
+```go
+package sorting
+func BubbleSort(arr []int) {
+ n := len(arr)
+ for i := 0; i < n-1; i++ {
+ for j := 0; j < n-i-1; j++ {
+ if arr[j] > arr[j+1] {
+ arr[j], arr[j+1] = arr[j+1], arr[j]
+ }
+ }
+ }
+}
+
+func QuickSort(arr []int) {
+ quickSort(arr, 0, len(arr)-1)
+}
+
+func quickSort(arr []int, low, high int) {
+ if low < high {
+ pivot := partition(arr, low, high)
+ quickSort(arr, low, pivot-1)
+ quickSort(arr, pivot+1, high)
+ }
+}
+
+func partition(arr []int, low, high int) int {
+ pivot := arr[high]
+ i := low - 1
+ for j := low; j < high; j++ {
+ if arr[j] < pivot {
+ i++
+ arr[i], arr[j] = arr[j], arr[i]
+ }
+ }
+ arr[i+1], arr[high] = arr[high], arr[i+1]
+ return i + 1
+}
+```
+- The code contains **two sorting methods**, Bubble Sort and Quick Sort, which arrange numbers in order from smallest to largest.
+- **Bubble Sort** works by repeatedly comparing two numbers side by side and swapping them if they are in the wrong order. It keeps doing this until the whole list is sorted.
+- **Quick Sor**t is faster. It picks a "pivot" number and splits the list into two groups — numbers smaller than the pivot and numbers bigger than it. Then it sorts each group separately.
+- The **function** partition helps Quick Sort decide where to split the list based on the pivot number.
+- In short, **Bubble Sort is simple but slow,** while **Quick Sort is smarter and usually much faster for big lists of numbers**.
+
+You create the sorting folder and then move `sorting.go` into it to organize your code properly so that the Go module can reference it as `gosort-bench/sorting`.
+
+```console
+mkdir sorting
+mv sorting.go sorting/
+```
+
+4. Add Benchmark Tests
+
+Create another file called s**orting_benchmark_test.go**:
+
+```console
+nano sorting_benchmark_test.go
+````
+
+Paste the below code:
+
+```go
+package sorting_test
+import (
+ "math/rand"
+ "testing"
+ "gosort-bench/sorting"
+)
+const LENGTH = 10000
+func makeRandomNumberSlice(n int) []int {
+ numbers := make([]int, n)
+ for i := range numbers {
+ numbers[i] = rand.Intn(n)
+ }
+ return numbers
+}
+func BenchmarkBubbleSort(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ b.StopTimer()
+ numbers := makeRandomNumberSlice(LENGTH)
+ b.StartTimer()
+ sorting.BubbleSort(numbers)
+ }
+}
+
+func BenchmarkQuickSort(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ b.StopTimer()
+ numbers := makeRandomNumberSlice(LENGTH)
+ b.StartTimer()
+ sorting.QuickSort(numbers)
+ }
+}
+```
+
+- The code is a **benchmark test** that checks how fast Bubble Sort and Quick Sort run in Go.
+- It first creates a **list of 10,000 random numbers** each time before running a sort, so the test is fair and consistent.
+- **BenchmarkBubbleSort** measures the speed of sorting using the slower Bubble Sort method.
+- **BenchmarkQuickSort** measures the speed of sorting using the faster Quick Sort method.
+
+When you run **go test -bench=. -benchmem**, Go will show you how long each sort takes and how much memory it uses, so you can compare the two sorting techniques.
+
+### Run the Benchmark
+
+Execute the benchmark suite using the following command:
+```console
+go test -bench=. -benchmem
+```
+- **-bench=.** - runs all functions starting with Benchmark.
+- **-benchmem** - also shows memory usage (allocations per operation).
+
+You should see the output similar to this:
+
+```output
+goos: linux
+goarch: arm64
+pkg: gosort-bench
+BenchmarkBubbleSort-4 32 36616759 ns/op 0 B/op 0 allocs/op
+BenchmarkQuickSort-4 3506 340873 ns/op 0 B/op 0 allocs/op
+PASS
+ok gosort-bench 2.905s
+```
+### Matrics Explanation
+
+- **ns/op** - nanoseconds per operation (lower is better).
+- **B/op** - bytes of memory used per operation.
+- **allocs/op** - how many memory allocations happened per operation.
+
+### Benchmark summary on Arm64
+Here is a summary of benchmark results collected on an Arm64 **D4ps_v6 Ubuntu Pro 24.04 LTS virtual machine**.
+
+| Benchmark | Value on Virtual Machine |
+|-------------------|--------------------------|
+| BubbleSort (ns/op) | 36,616,759 |
+| QuickSort (ns/op) | 340,873 |
+| BubbleSort runs | 32 |
+| QuickSort runs | 3,506 |
+| Allocations/op | 0 |
+| Bytes/op | 0 |
+| Total time (s) | 2.905 |
+
+### Benchmark summary on x86_64
+Here is a summary of the benchmark results collected on x86_64 **D4s_v6 Ubuntu Pro 24.04 LTS virtual machine**.
+
+| Benchmark | Value on Virtual Machine |
+|-------------------|--------------------------|
+| BubbleSort (ns/op) | 42,801,947 |
+| QuickSort (ns/op) | 512,726 |
+| BubbleSort runs | 27 |
+| QuickSort runs | 2,332 |
+| Allocations/op | 0 |
+| Bytes/op | 0 |
+| Total time (s) | 2.716 |
+
+
+### Benchmarking comparison summary
+
+When you compare the benchmarking results you will notice that on the Azure Cobalt 100:
+
+- **Arm64 maintains consistency** – the virtual machine delivered stable and predictable results, showing that Arm64 optimizations are effective for compute workloads.
+- **BubbleSort (CPU-heavy, O(n²))** – runs in **~36.6M ns/op**, proving that raw CPU performance on Arm64 is consistent and unaffected by environmental factors.
+- **QuickSort (efficient O(n log n))** – execution is very fast (**~341K ns/op**), demonstrating that Arm64 handles algorithmic workloads efficiently.
+- **No memory overhead** – the benchmark shows **0 B/op and 0 allocs/op**, confirming Golang’s memory efficiency is preserved on Arm64.
+- **Run counts align closely** – **BubbleSort (32 runs)** and **QuickSort (3,506 runs)** indicate Arm64 delivers repeatable and reliable performance.
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/create-instance.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/create-instance.md
new file mode 100644
index 0000000000..9571395aa2
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/create-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.
+
+
+
+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.
+
+
+
+9. Click on the "Review + Create" tab and review the configuration for your virtual machine. It should look like the following:
+
+
+
+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.
+
+
+
+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.
+
+
+
+{{% notice Note %}}
+
+To learn more about Arm-based virtual machine 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/golang-on-azure/deploy.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/deploy.md
new file mode 100644
index 0000000000..a97e52576e
--- /dev/null
+++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/deploy.md
@@ -0,0 +1,121 @@
+---
+title: Install Golang
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+
+## Install Golang on Ubuntu Pro 24.04 LTS (Arm64)
+This section covers installing the latest Golang version on **Ubuntu Pro 24.04 LTS Arm64**, configuring the environment, and verifying the setup.
+
+1. Download the Golang archive
+
+This command downloads the official Golang package for Linux Arm64 from the Golang website.
+
+```console
+wget https://go.dev/dl/go1.25.0.linux-arm64.tar.gz
+```
+{{% notice Note %}}
+There are many enhancements added to Golang version 1.18, that has resulted in up to a 20% increase in performance for Golang workloads on Arm-based servers. Please see [this reference content](https://aws.amazon.com/blogs/compute/making-your-go-workloads-up-to-20-faster-with-go-1-18-and-aws-graviton/) for the details.
+
+The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) also recommends Golang version 1.18 as the minimum recommended on the Arm platforms.
+{{% /notice %}}
+
+2. Extract the archive into `/usr/local`
+
+This unpacks the Golang files into the system directory /usr/local, which is a standard place for system-wide software.
+
+```console
+sudo tar -C /usr/local -xzf ./go1.25.0.linux-arm64.tar.gz
+```
+
+3. Add Golang to your system PATH
+
+This updates your .bashrc file so your shell can recognize the Golang command from anywhere.
+
+```console
+echo 'export PATH="$PATH:/usr/local/go/bin"' >> ~/.bashrc
+```
+
+4. Apply the PATH changes immediately
+
+This reloads your .bashrc so you don’t need to log out and log back in for the changes to take effect.
+
+```console
+source ~/.bashrc
+```
+
+5. Verify Golang installation
+
+This checks if Golang is installed correctly and shows the installed version.
+
+```console
+go version
+```
+
+You should see an output similar to:
+
+```output
+go version go1.25.0 linux/arm64
+```
+6. Check Golang environment settings
+
+This displays Golang’s environment variables (like GOROOT and GOPATH) to ensure they point to the correct installation.
+
+```console
+go env
+```
+
+You should see an output similar to:
+
+```output
+AR='ar'
+CC='gcc'
+CGO_CFLAGS='-O2 -g'
+CGO_CPPFLAGS=''
+CGO_CXXFLAGS='-O2 -g'
+CGO_ENABLED='1'
+CGO_FFLAGS='-O2 -g'
+CGO_LDFLAGS='-O2 -g'
+CXX='g++'
+GCCGO='gccgo'
+GO111MODULE=''
+GOARCH='arm64'
+GOARM64='v8.0'
+GOAUTH='netrc'
+GOBIN=''
+GOCACHE='/home/ubuntu/.cache/go-build'
+GOCACHEPROG=''
+GODEBUG=''
+GOENV='/home/ubuntu/.config/go/env'
+GOEXE=''
+GOEXPERIMENT=''
+GOFIPS140='off'
+GOFLAGS=''
+GOGCCFLAGS='-fPIC -pthread -Wl,--no-gc-sections -fmessage-length=0 -ffile-prefix-map=/tmp/go-build119388372=/tmp/go-build -gno-record-gcc-switches'
+GOHOSTARCH='arm64'
+GOHOSTOS='linux'
+GOINSECURE=''
+GOMOD='/dev/null'
+GOMODCACHE='/home/ubuntu/go/pkg/mod'
+GONOPROXY=''
+GONOSUMDB=''
+GOOS='linux'
+GOPATH='/home/ubuntu/go'
+GOPRIVATE=''
+GOPROXY='https://proxy.golang.org,direct'
+GOROOT='/usr/local/go'
+GOSUMDB='sum.golang.org'
+GOTELEMETRY='local'
+GOTELEMETRYDIR='/home/ubuntu/.config/go/telemetry'
+GOTMPDIR=''
+GOTOOLCHAIN='auto'
+GOTOOLDIR='/usr/local/go/pkg/tool/linux_arm64'
+GOVCS=''
+GOVERSION='go1.25.0'
+GOWORK=''
+PKG_CONFIG='pkg-config'
+```
+Golang installation on Ubuntu Pro 24.04 LTS Arm64 is complete. You can now proceed with Golang development or baseline testing.
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/final-vm.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/final-vm.png
new file mode 100644
index 0000000000..5207abfb41
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/final-vm.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/go-web.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/go-web.png
new file mode 100644
index 0000000000..66618480f2
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/go-web.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance.png
new file mode 100644
index 0000000000..285cd764a5
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance1.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance1.png
new file mode 100644
index 0000000000..b9d22c352d
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance1.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance4.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance4.png
new file mode 100644
index 0000000000..2a0ff1e3b0
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/instance4.png differ
diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/ubuntu-pro.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/ubuntu-pro.png
new file mode 100644
index 0000000000..d54bd75ca6
Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/images/ubuntu-pro.png differ