Refactor documentation: update titles and section headings for clarity and consistency across TypeScript guides

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/typescript-on-gcp/_index.md

@@ -1,15 +1,15 @@
 ---
-title: Deploy TypeScript on Google Cloud Axion-based C4A virtual machines
+title: Deploy TypeScript on Google Cloud C4A virtual machines
 
 minutes_to_complete: 30
 
 who_is_this_for: This is an introductory topic for developers deploying and optimizing TypeScript workloads on Arm64 Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors.
 
 learning_objectives:
-  - Provision an Arm-based SUSE Linux Enterprise Server (SLES) virtual machine (VM) on Google Cloud (C4A with Axion processors)
+  - Provision an Arm-based SUSE Linux Enterprise Server (SLES) virtual machine (VM) on Google Cloud 
   - Install TypeScript on a SUSE Arm64 C4A instance
   - Validate TypeScript functionality by creating, compiling, and running a simple TypeScript script on a Arm64 VM
-  - Benchmark TypeScript performance using a JMH-style custom benchmark with perf_hooks on Arm64 architecture
+  - Benchmark TypeScript performance using a JMH-style custom benchmark with the perf_hooks module on Arm64 architecture
 
 prerequisites:
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled

content/learning-paths/servers-and-cloud-computing/typescript-on-gcp/background.md

@@ -1,5 +1,5 @@
 ---
-title: Getting started with TypeScript on Google Axion C4A instances
+title: Get started with TypeScript on Google Axion C4A instances
 
 weight: 2
 
@@ -8,12 +8,12 @@ layout: "learningpathall"
 
 ## Introduction
 
-This Learning Path shows you how to deploy and benchmark TypeScript applications on Arm-based Google Cloud C4A instances powered by Axion processors. You'll provision a SUSE Linux Enterprise Server (SLES) virtual machine (VM), install and configure TypeScript, and measure performance using a JMH-style custom benchmark. By combining TypeScript’s strong typing and developer tooling with the high performance and energy efficiency of Arm-based C4A instances, you can build robust, scalable, and cost-effective cloud-native applications optimized for the future of cloud on Arm.
+In this Learning Path, you'll deploy and benchmark TypeScript applications on Arm-based Google Cloud C4A instances powered by Axion processors. You'll provision a SUSE Linux Enterprise Server (SLES) virtual machine (VM), install and configure TypeScript, and measure performance using a JMH-style custom benchmark. This process shows you how to use TypeScript with Arm-based cloud infrastructure and helps you evaluate performance and compatibility for cloud-native workloads.
 
 
 ## Google Axion C4A Arm instances in Google Cloud
 
-Google Axion C4A is a family of Arm-based virtual machines built on Google’s custom Axion CPU, which is based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, these virtual machines offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
+Google Axion C4A is a family of Arm-based virtual machines built on Google’s custom Axion CPU, which is based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, they offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
 
 The C4A series provides a cost-effective alternative to x86 virtual machines while leveraging the scalability and performance benefits of the Arm architecture on Google Cloud.
 
@@ -25,4 +25,4 @@ TypeScript is an open-source, strongly-typed programming language developed and
 
 TypeScript builds on JavaScript by adding features like static typing and interfaces. Any valid JavaScript code works in TypeScript, but TypeScript gives you extra tools to write code that is easier to maintain and less prone to errors. 
 
-TypeScript is widely used for web applications, server-side development (Node.js), and large-scale JavaScript projects where type safety and code quality are important. Learn more from the [TypeScript official website](https://www.typescriptlang.org/) and the [TypeScript handbook and documentation](https://www.typescriptlang.org/docs/).
+TypeScript is widely used for web applications, server-side development (Node.js), and large-scale JavaScript projects where type safety and code quality are important. Learn more by visiting the [TypeScript official website](https://www.typescriptlang.org/) and the [TypeScript handbook and documentation](https://www.typescriptlang.org/docs/).

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

@@ -6,14 +6,13 @@ weight: 5
 layout: learningpathall
 ---
 
-## Set up your TypeScript baseline
+## Overview
 This section walks you through the baseline setup and validation of TypeScript on a Google Cloud C4A (Axion Arm64) virtual machine running SUSE Linux. The goal is to confirm that your TypeScript environment is functioning correctly, from initializing a project to compiling and executing a simple TypeScript file, ensuring a solid foundation before performance or benchmarking steps.
 
-## Set up a TypeScript project
-Before running any tests, you’ll create a dedicated project directory and initialize a minimal TypeScript environment.
-
 ## Create project folder
 
+Before running any tests, you’ll create a dedicated project directory and initialize a minimal TypeScript environment.
+
 Start by creating a new folder to hold your TypeScript project files:
 
 ```console
@@ -22,9 +21,9 @@ cd ~/typescript-benchmark
 ```
 This creates a workspace named `typescript-benchmark` in your home directory, ensuring all TypeScript configuration and source files are organized separately from system files and global modules.
 
-### Initialize npm project
+## Initialize npm project
 
-Next, initialize a new Node.js project. This creates a `package.json` file that defines your project metadata, dependencies, and scripts.
+Next, initialize a new Node.js project. This creates a `package.json` file that defines your project metadata, dependencies, and scripts:
 
 ```console
 npm init -y
@@ -57,7 +56,7 @@ You should see output similar to:
 ## Perform baseline testing
 With the TypeScript environment configured, you’ll now perform a baseline functionality test to confirm that TypeScript compilation and execution work correctly on your Google Cloud SUSE Arm64 VM.
 
-### Create a simple TypeScript file
+## Create a simple TypeScript file
 
 Create a file named `hello.ts` with the following content:
 
@@ -70,7 +69,7 @@ console.log(greet("GCP SUSE ARM64"));
 ```
 This simple function demonstrates TypeScript syntax, type annotations, and basic console output.
 
-### Compile TypeScript
+## Compile TypeScript
 
 Use the TypeScript compiler (tsc) to transpile the .ts file into JavaScript:
 
@@ -79,7 +78,7 @@ tsc hello.ts
 ```
 This generates a new file named `hello.js` in the same directory.
 
-### Run compiled JavaScript
+## Run compiled JavaScript
 
 Now, execute the compiled JavaScript using Node.js. This step verifies that:
 

content/learning-paths/servers-and-cloud-computing/typescript-on-gcp/benchmarking.md

@@ -56,16 +56,16 @@ Code explanation:
 
 This JMH-style benchmarking approach provides more accurate and repeatable performance metrics than a single execution, making it ideal for performance testing on Arm-based systems.
 
-### Compile the TypeScript Benchmark
+## Compile the TypeScript Benchmark
 First, compile the benchmark file from TypeScript to JavaScript using the TypeScript compiler (tsc):
 
 ```console
 tsc benchmark_jmh.ts
 ```
-This command transpiles your TypeScript code into standard JavaScript, generating a file named `benchmark_jmh.js` in the same directory.
-The resulting JavaScript can be executed by Node.js, allowing you to measure performance on your Google Cloud C4A (Arm64) virtual machine.
+This command converts your TypeScript file into JavaScript and creates a new file called `benchmark_jmh.js` in your project directory.  
+You can now run this JavaScript file with Node.js to benchmark performance on your Google Cloud C4A (Arm64) VM.
 
-### Run the Benchmark
+## Run the Benchmark
 Now, execute the compiled JavaScript file with Node.js:
 
 ```console
@@ -87,33 +87,24 @@ Iteration 10: 0.673 ms
 
 Average execution time over 10 iterations: 0.888 ms
 ```
+## Interpret your TypeScript performance data on Arm
 
-## Run and analyze TypeScript benchmark results on Google Axion C4A
+Each iteration measures how long it takes to run the benchmarked function once, while the average execution time is calculated by dividing the total time for all runs by the number of iterations. Running the benchmark multiple times helps smooth out fluctuations caused by factors like CPU scheduling, garbage collection, or memory caching. This approach produces more consistent and meaningful performance data, similar to the methodology used by Java’s JMH benchmarking framework.
 
-  * Iteration times → Each iteration represents the time taken for one complete execution of the benchmarked function.
-  * Average execution time → Calculated as the total of all iteration times divided by the number of iterations. This gives a stable measure of real-world performance.
-  * Why multiple iterations?
-    A single run can be affected by transient factors such as CPU scheduling, garbage collection, or memory caching.
-    Running multiple iterations and averaging the results smooths out variability, producing more repeatable and statistically meaningful data, similar to Java’s JMH benchmarking methodology.
-    
-### Interpret your TypeScript performance data on Arm
-
-The average execution time reflects how efficiently the function executes under steady-state conditions.
-The first iteration often shows higher latency because Node.js performing initial JIT (Just-In-Time) compilation and optimization, a common warm-up behavior in JavaScript/TypeScript benchmarks.
+The average execution time reflects how efficiently the function executes under steady-state conditions. The first iteration often shows higher latency because Node.js performing initial JIT (Just-In-Time) compilation and optimization, a common warm-up behavior in JavaScript/TypeScript benchmarks.
 
 ### Benchmark summary on Arm64
 Results from the earlier run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP (SUSE):
 
 | Iteration | 1     | 2     | 3     | 4     | 5     | 6     | 7     | 8     | 9     | 10    | Average |
 |-----------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|---------|
 | Time (ms) | 2.286 | 0.749 | 1.145 | 0.674 | 0.671 | 0.671 | 0.672 | 0.667 | 0.667 | 0.673 | 0.888   |
+## Summarize TypeScript benchmarking results on Arm64
 
-### TypeScript performance benchmarking summary on Arm64
-
-When you look at the benchmarking results, you will notice that on the Google Axion C4A Arm-based instances:
+Here’s what the benchmark results show for Google Axion C4A Arm-based instances:
 
-- The average execution time on Arm64 (~0.888 ms) shows that CPU-bound TypeScript operations run efficiently on Arm-based VMs.
-- Initial iterations may show slightly higher times due to runtime warm-up and optimization overhead, which is common across architectures.  
-- Arm64 demonstrates stable iteration times after the first run, indicating consistent performance for repeated workloads.  
+- The average execution time on Arm64 is about 0.888 ms, which means TypeScript code runs efficiently on Arm-based VMs.
+- The first run is usually a bit slower because Node.js is warming up and optimizing the code. This is normal for all architectures.
+- After the first run, the times are very consistent, showing that Arm64 delivers stable performance for repeated tasks.
 
-This demonstrates that Google Cloud C4A Arm64 virtual machines provide production-grade stability and throughput for TypeScript workloads, whether used for application logic, scripting, or performance-critical services.
+These results confirm that Google Cloud C4A Arm64 virtual machines are reliable and fast for running TypeScript workloads, whether you’re building application logic, scripts, or performance-sensitive services.

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

@@ -6,22 +6,22 @@ weight: 4
 layout: learningpathall
 ---
 
-## Install TypeScript on GCP VM
+## Overview
 This section walks you through installing TypeScript and its dependencies on a Google Cloud Platform (GCP) SUSE Arm64 virtual machine. You’ll install Node.js, npm, TypeScript, and ts-node, and verify that everything works correctly.
 
-Running TypeScript on Google Cloud C4A instances, powered by Axion Arm64 processors, provides a high-performance and energy-efficient platform for Node.js-based workloads.
+Running TypeScript on Google Cloud C4A instances, powered by Axion Arm64 processors provides a high-performance and energy-efficient platform for Node.js-based workloads.
 
-### Update SUSE System
+## Update SUSE system
 Before installing new packages, refresh the repositories and update existing ones to ensure your environment is current and secure:
 
 ```console
 sudo zypper refresh
 sudo zypper update -y
 ```
-Keeping your system up to date ensures that dependencies, libraries, and compilers required for Node.js and TypeScript work seamlessly on the Arm64 architecture.
+Updating your system helps make sure all the tools and libraries you need for Node.js and TypeScript work smoothly on Arm64.
 
-### Install Node.js and npm
-Node.js provides the JavaScript runtime that powers TypeScript execution, while npm (Node Package Manager) manages project dependencies and global tools.
+## Install Node.js and npm
+Node.js is the JavaScript runtime that runs your TypeScript code. npm is the tool you use to install and manage packages and tools for your projects.
 
 Install both packages using SUSE’s repositories:
 
@@ -66,5 +66,4 @@ Version 5.9.3
 v10.9.2
 ```
 
-Node.js, npm, and TypeScript are now successfully installed and verified on your Google Cloud C4A (Arm64) virtual machine.
-You’re ready to create and execute TypeScript scripts for testing, deployment, or performance benchmarking.
+You’ve now installed and verified Node.js, npm, and TypeScript on your Google Cloud C4A (Arm64) virtual machine. You’re ready to start creating and running TypeScript scripts for testing, deployment, or performance checks.

content/learning-paths/servers-and-cloud-computing/typescript-on-gcp/instance.md

@@ -8,15 +8,15 @@ layout: learningpathall
 
 ## Overview
 
-In this section, you will learn how to provision a Google Axion C4A Arm virtual machine on Google Cloud Platform (GCP) using the `c4a-standard-4` (4 vCPUs, 16 GB memory) machine type in the Google Cloud Console.  
+In this section, you'll set up a Google Axion C4A Arm virtual machine on Google Cloud Platform (GCP) using the `c4a-standard-4` machine type. This instance gives you four virtual CPUs and 16 GB of memory. You'll use the Google Cloud Console to complete each step. 
 
 {{% notice Note %}}
 For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](https://learn.arm.com/learning-paths/servers-and-cloud-computing/csp/google/).
 {{% /notice %}}
 
-## Provision a Google Axion C4A Arm VM in Google Cloud Console
+## Create the virtual machine
 
-To create a virtual machine based on the C4A instance type:
+To create the virtual machine, follow these steps:
 - Navigate to the [Google Cloud Console](https://console.cloud.google.com/).
 - Go to **Compute Engine > VM Instances** and select **Create Instance**. 
 - Under **Machine configuration**: