rephrase

Author: SamirPS

content/guides/github-action-integration/index.md

@@ -42,7 +42,7 @@ In our example, we generate 1 user coming at once to see if our simulation is wo
 Now that we have our test locally, we need to deploy the package to Gatling Enterprise to create a simulation.
 
 {{< alert info >}}
-This video showcases the JavaScript SDK, but the same process applies to all SDKs that Gatling provides.
+While this video demonstrates the JavaScript SDK, the same process applies to all Gatling SDKs.
 {{< /alert >}}
 
 {{< youtube jYPc6lwBAAQ >}}

content/guides/gitlab-ci-integration/index.md

@@ -11,9 +11,7 @@ date: 2025-03-11T13:35:00+02:00
 
 ---
 
-At Gatling, we strongly believe the shift-left approach is fundamental to ensuring application quality. This methodology, which involves integrating testing as early as possible in the development cycle, is particularly crucial for performance testing. Detecting and resolving performance issues before production deployment helps prevent critical and costly situations.
-
-In this guide, we demonstrate how to integrate performance testing into your CI/CD pipeline using Gatling and Gitlab CI. This approach enables you to automate your performance tests and ensure application reliability.
+Performance testing is a critical component of modern software development. By integrating Gatling Enterprise with GitLab CI, you can incorporate performance testing into your development workflow, ensuring your applications meet performance standards before reaching production.
 
 ## Prerequisites
 
@@ -25,66 +23,76 @@ In this guide, we demonstrate how to integrate performance testing into your CI/
 
 ### Create the Scenario
 
-In this tutorial, we create a small scenario using our JS SDK. Our users will load the home page of our [e-commerce website demo](https://ecomm.gatling.io/).
+Let's create a simple scenario that loads our [e-commerce demo website](https://ecomm.gatling.io/).
 
 {{< include-code "ecommerce#ecommerce-example" ts java scala kt>}}
 
 ### Generate the user and assertions
 
-In our example, we generate 1 user coming at once to see if our simulation is working. After that, we define our assertions, which allows us to assert the maximum or minimum response time, the percentage of successful requests, and more. In our case, we only check if we have more than 90% successful requests.
+We'll start with a single user to verify our simulation works correctly. Then we'll add assertions to validate our test results. In this example, we'll check that more than 90% of requests are successful.
 
 {{< include-code "ecommerce#set-up" ts java scala kt>}}
 
 ## Gatling Enterprise
 
 ### Deploy to Gatling Enterprise
 
-Now that we have our test locally, we need to deploy the package to Gatling Enterprise to create a simulation.
+Now that we have our test ready, we need to deploy the package to Gatling Enterprise.
 
 {{< alert info >}}
-This video showcases the JavaScript SDK, but the same process applies to all SDKs that Gatling provides.
+While this video demonstrates the JavaScript SDK specifically, the deployment process remains identical across all Gatling SDKs and CI/CD platforms we support.
 {{< /alert >}}
 
 {{< youtube jYPc6lwBAAQ >}}
 
 ### Create the Simulation
 
-Now that our package is on Gatling Enterprise, we need to create a simulation.
+{{< alert info >}}
+This step is applicable to all CI/CD platforms supported by Gatling Enterprise.
+{{< /alert >}}
+
+Next, we'll create a simulation in Gatling Enterprise using our deployed package.
 
 {{< youtube 7Gb4BcHU0P8 >}}
 
 ### Copy Your Simulation ID
 
-Don't forget to copy your `simulation Id` (click on the three dots to the right of your simulation name); we will need it later.
+Make sure to copy the `simulation Id` by clicking the three dots menu next to your simulation name, as we'll use this ID in subsequent steps.
 
 ### Create an API Key
 
-Now, for Gitlab to communicate with Gatling Enterprise and launch the simulation, you need to create an API key.
+{{< alert info >}}
+This step is applicable to all CI/CD platforms supported by Gatling Enterprise.
+{{< /alert >}}
+
+To enable Gitlab CI to interact with Gatling Enterprise and trigger simulations, you'll need to generate an API key.
 
 {{< youtube iP4_WM9wTNA >}}
 
-Now that everything is set up on the Gatling Enterprise side, it's time to create our CI script on Gitlab.
+With Gatling Enterprise configured, we can now proceed to setting up our GitLab CI pipeline.
 
 ## Gitlab CI
 
 ### Set up the Secrets and Environment
 
-To successfully launch our workflow, we begin by configuring a secret in our Gitlab repository. This secret is essential for securely managing access to external services and APIs. To add the secret, follow these steps:
+To run simulations from GitLab CI, you'll first need to configure a secure API token. Follow these steps to set up the required variable:
+
+1. Navigate to your GitLab repository
+2. Access the `Settings` menu
+3. Select `CI/CD` from the sidebar
+4. Click on `Variables`
+5. Press the `Add variable` button
+6. Choose `Masked and hidden` for `Visibility`
+7. Enter `GATLING_ENTERPRISE_API_TOKEN` as the `Key`
+8. Paste your API token as the `Value`
 
-1. Navigate to your Gitlab repository
-2. Go to the `Settings` tab
-3. Click on `CI/CD`
-4. Select `Variables`
-5. Click on the `Add variable` button
-6. Select `Masked and hidden` on `Visibility`
-6. Set `GATLING_ENTERPRISE_API_TOKEN` on `Key`
-7. Set the value of the `GATLING_ENTERPRISE_API_TOKEN` to `Value`
+If you need to generate a new API token, follow our guide [here]({{< ref "../reference/execute/cloud/admin/api-tokens" >}}).
 
-If you don't have an API token yet, you can learn how to create one by following the instructions on this [page]({{< ref "../reference/execute/cloud/admin/api-tokens" >}})
+### Configure the Pipeline
 
-### Understand the Workflow
+Let's set up a basic GitLab CI pipeline that will run your performance tests. The pipeline configuration will trigger a simulation using the provided **`simulation Id`**.
 
-In this example, we configure a workflow which will only start a simulation as already configured and uploaded on Gatling Enterprise.
+Here's the pipeline configuration:
 
 ```yaml
 stages:
@@ -101,16 +109,16 @@ run-gatling-enterprise:
     SIMULATION_ID: '00000000-0000-0000-0000-000000000000'
 ```
 
-If you wish to customize this workflow further, refer to our [Gitlab documentation]({{< ref "../reference/integrations/ci-cd/gitlab-ci" >}}) for more details and options.
+For advanced pipeline customization options, check our [GitLab CI documentation]({{< ref "../reference/integrations/ci-cd/gitlab-ci" >}}).
 
-### Launch the Workflow
+### Run the Pipeline
 
-Now that our requirements are set up, go to Gitlab → Build → Pipeline and click on `new pipeline`. On variable put `SIMULATION_ID` on key and your `simulation Id` you copied before as value and click on `New pipeline`.
+With everything configured, you can now trigger the pipeline from GitLab CI/CD. Provide your **`simulation Id`** when running the pipeline, and you'll be able to monitor the test execution both in GitLab and Gatling Enterprise.
 
-{{< youtube Ocv66gH5ZjM >}}
+{{< youtube UqRzLjJqkds >}}
 
 ## Conclusion
 
-Integrating Gatling with Gitlab CI offers a solution for automating performance testing. By adopting this shift-left approach, you can identify and address performance issues early in the development cycle, ensuring higher application quality and reliability.
+Integrating Gatling with GitLab CI provides a robust solution for automated performance testing in your development pipeline. By implementing this shift-left approach, you can identify and address performance issues early in the development cycle, ensuring higher application quality and reliability.
 
-This integration streamlines the testing process and enhances efficiency between development teams. With Gatling Enterprise and Gitlab CI, you can create a workflow that monitors your application's performance
+This integration streamlines the testing process and enhances collaboration between development teams. With Gatling Enterprise and GitLab CI, you can create a seamless pipeline that continuously monitors your application's performance, making it easier to maintain high standards of application quality throughout the development lifecycle.