diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml
index 42a381e003125a4d9d0c33a09cde2979c6aa64b4..ce57a0f0d40a918600d55e3c04154075ae465679 100644
--- a/.github/workflows/gradle.yml
+++ b/.github/workflows/gradle.yml
@@ -1,6 +1,6 @@
+---
 # This workflow will build a Java project with Maven
 # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
-
 name: Gradle build
 
 on:
@@ -11,15 +11,14 @@ on:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 17
-      uses: actions/setup-java@v2
-      with:
-        java-version: '17'
-        distribution: 'adopt'
-    - name: Build with Gradle
-      run: gradle clean test
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'gradle'
+      - name: Build with Gradle
+        run: ./gradlew clean test
\ No newline at end of file
diff --git a/.github/workflows/living-documentation.yml b/.github/workflows/living-documentation.yml
index aa95cfbad8cbaceedd715d42d9df2776b38ffeed..dd5f7c9f0aba4073786e86a43ba5fd949eae88e1 100644
--- a/.github/workflows/living-documentation.yml
+++ b/.github/workflows/living-documentation.yml
@@ -1,3 +1,4 @@
+---
 name: Living Documentation
 
 on:
@@ -6,32 +7,32 @@ on:
   pull_request:
     branches: [ master ]
 
+permissions:
+  contents: write
+
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 17
-      uses: actions/setup-java@v2
-      with:
-        java-version: '17'
-        distribution: 'adopt'
-        cache: maven
-
-    - name: Cache the Maven packages to speed up build
-      uses: actions/cache@v1
-      with:
-        path: ~/.m2
-        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
-        restore-keys: ${{ runner.os }}-m2
-
-    - name: Build with Maven
-      run: mvn -B verify --file pom.xml -Denvironment=with_screenshots
-
-    - name: Deploy
-      uses: JamesIves/github-pages-deploy-action@4.1.1
-      with:
-        branch: gh-pages # The branch the action should deploy to.
-        folder: target/site/serenity # The folder the action should deploy.
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'adopt'
+          cache: 'maven'
+      - name: Cache the Maven packages to speed up build
+        uses: actions/cache@v3
+        with:
+          # Based on: https://github.com/actions/cache/blob/main/examples.md#java---maven
+          path: ~/.m2/repository
+          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-maven-
+      - name: Build with Maven
+        # TODO: Add Maven wrapper into the codebase and use it to run build
+        run: mvn -B verify --file pom.xml -Denvironment=with_screenshots
+      - name: Deploy
+        uses: JamesIves/github-pages-deploy-action@4.1.1
+        with:
+          branch: gh-pages # The branch the action should deploy to.
+          folder: target/site/serenity # The folder the action should deploy.
diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 2b432c23f0538fbc269f1ccfd6b6a7676bfa0b5e..d1846fd089ae420342805b4b908ccea94d91f0fa 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -1,26 +1,27 @@
+---
 # This workflow will build a Java project with Maven
 # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
-
-name: Maven Build
+name: Maven build
 
 on:
   push:
-    branches: [ master ]
+    branches:
+      - master
   pull_request:
-    branches: [ master ]
+    branches:
+      - master
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
-
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 17
-      uses: actions/setup-java@v2
-      with:
-        java-version: '17'
-        distribution: 'adopt'
-        cache: maven
-    - name: Build with Maven
-      run: mvn -B verify --file pom.xml
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: 'maven'
+      - name: Build with Maven
+        # TODO: Add Maven wrapper into the codebase and use it to run build
+        run: mvn -B verify --file pom.xml
diff --git a/README.md b/README.md
index ab3e22bb93eca7aa0e817768214b2c936f6d9007..3d44df97bbd5ddf6faaa6487782d6abd43245470 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,28 @@
 # Getting started with Serenity and Cucumber
 
-Serenity BDD is a library that makes it easier to write high quality automated acceptance tests, with powerful reporting and living documentation features. It has strong support for both web testing with Selenium, and API testing using RestAssured.
+Serenity BDD is a library that makes it easier to write high-quality automated acceptance tests,
+with powerful reporting and living documentation features.
+It has strong support for both web testing with [Selenium](https://www.selenium.dev/),
+and API testing using [REST Assured](https://rest-assured.io/).
 
-Serenity strongly encourages good test automation design, and supports several design patterns, including classic Page Objects, the newer Lean Page Objects/ Action Classes approach, and the more sophisticated and flexible Screenplay pattern.
+Serenity strongly encourages good test automation design, and supports several design patterns,
+including classic Page Objects, the newer Lean Page Objects/ Action Classes approach,
+and the more sophisticated and flexible Screenplay pattern.
 
 The latest version of Serenity supports Cucumber 6.x.
 
 ## The starter project
-The best place to start with Serenity and Cucumber is to clone or download the starter project on Github ([https://github.com/serenity-bdd/serenity-cucumber-starter](https://github.com/serenity-bdd/serenity-cucumber-starter)). This project gives you a basic project setup, along with some sample tests and supporting classes. There are two versions to choose from. The master branch uses a more classic approach, using action classes and lightweight page objects, whereas the **[screenplay](https://github.com/serenity-bdd/serenity-cucumber-starter/tree/screenplay)** branch shows the same sample test implemented using Screenplay.
+
+The best place to start with Serenity and Cucumber is to clone or download the starter project on GitHub
+([https://github.com/serenity-bdd/serenity-cucumber-starter](https://github.com/serenity-bdd/serenity-cucumber-starter)).
+This project gives you a basic project setup, along with some sample tests and supporting classes.
+There are two versions to choose from. The master branch uses a more classic approach, using action classes and lightweight page objects, whereas the **[screenplay](https://github.com/serenity-bdd/serenity-cucumber-starter/tree/screenplay)** branch shows the same sample test implemented using Screenplay.
 
 ### The project directory structure
-The project has build scripts for both Maven and Gradle, and follows the standard directory structure used in most Serenity projects:
+
+The project has build scripts for both Maven and Gradle,
+and follows the standard directory structure used in most Serenity projects:
+
 ```Gherkin
 src
   + main
@@ -18,14 +30,16 @@ src
     + java                        Test runners and supporting code
     + resources
       + features                  Feature files
-
    + search                  Feature file subdirectories

-             search_by_keyword.feature
+        + search                  Feature file subdirectories
+            search_by_keyword.feature
 ```
 
-Serenity 2.2.13 introduced integration with WebdriverManager to download webdriver binaries.
+Serenity 2.2.13 introduced integration with [WebDriverManager](https://bonigarcia.dev/webdrivermanager/) to download webdriver binaries.
 
 ## The sample scenario
-Both variations of the sample project uses the sample Cucumber scenario. In this scenario, Sergey (who likes to search for stuff) is performing a search on the internet:
+
+Both variations of the sample project use the sample Cucumber scenario.
+In this scenario, Sergey (who likes to search for stuff) is performing a search on the internet:
 
 ```Gherkin
 Feature: Search by keyword
@@ -37,7 +51,13 @@ Feature: Search by keyword
 ```
 
 ### The Screenplay implementation
-The sample code in the master branch uses the Screenplay pattern. The Screenplay pattern describes tests in terms of actors and the tasks they perform. Tasks are represented as objects performed by an actor, rather than methods. This makes them more flexible and composable, at the cost of being a bit more wordy. Here is an example:
+
+The sample code in the master branch uses the Screenplay pattern.
+The Screenplay pattern describes tests in terms of actors and the tasks they perform.
+Tasks are represented as objects performed by an actor, rather than methods.
+This makes them more flexible and composable, at the cost of being a bit more wordy.
+Here is an example:
+
 ```java
     @Given("{actor} is researching things on the internet")
     public void researchingThings(Actor actor) {
@@ -59,9 +79,11 @@ The sample code in the master branch uses the Screenplay pattern. The Screenplay
     }
 ```
 
-Screenplay classes emphasise reusable components and a very readable declarative style, whereas Lean Page Objects and Action Classes (that you can see further down) opt for a more imperative style.
+Screenplay classes emphasise reusable components and a very readable declarative style,
+whereas Lean Page Objects and Action Classes (that you can see further down) opt for a more imperative style.
 
 The `NavigateTo` class is responsible for opening the Wikipedia home page:
+
 ```java
 public class NavigateTo {
     public static Performable theWikipediaHomePage() {
@@ -72,6 +94,7 @@ public class NavigateTo {
 ```
 
 The `LookForInformation` class does the actual search:
+
 ```java
 public class LookForInformation {
     public static Performable about(String searchTerm) {
@@ -84,7 +107,8 @@ public class LookForInformation {
 }
 ```
 
-In Screenplay, we keep track of locators in light weight page or component objects, like this one:
+In Screenplay, we keep track of locators in lightweight page or component objects, like this one:
+
 ```java
 class SearchForm {
     static Target SEARCH_FIELD = Target.the("search field")
@@ -93,11 +117,13 @@ class SearchForm {
 }
 ```
 
-The Screenplay DSL is rich and flexible, and well suited to teams working on large test automation projects with many team members, and who are reasonably comfortable with Java and design patterns. 
+The Screenplay DSL is rich and flexible, and well suited to teams working on large test automation projects with many team members,
+and who are reasonably comfortable with Java and design patterns. 
 
 ### The Action Classes implementation.
 
-A more imperative-style implementation using the Action Classes pattern can be found in the `action-classes` branch. The glue code in this version looks this this:
+A more imperative-style implementation using the Action Classes pattern can be found in the `action-classes` branch.
+The glue code in this version looks this:
 
 ```java
     @Given("^(?:.*) is researching things on the internet")
@@ -117,6 +143,7 @@ A more imperative-style implementation using the Action Classes pattern can be f
 ```
 
 These classes are declared using the Serenity `@Steps` annotation, shown below:
+
 ```java
     @Steps
     NavigateTo navigateTo;
@@ -128,11 +155,17 @@ These classes are declared using the Serenity `@Steps` annotation, shown below:
     SearchResult searchResult;
 ```
 
-The `@Steps`annotation tells Serenity to create a new instance of the class, and inject any other steps or page objects that this instance might need.
+The `@Steps`annotation tells Serenity to create a new instance of the class,
+and inject any other steps or page objects that this instance might need.
 
-Each action class models a particular facet of user behaviour: navigating to a particular page, performing a search, or retrieving the results of a search. These classes are designed to be small and self-contained, which makes them more stable and easier to maintain.
+Each action class models a particular facet of user behaviour: navigating to a particular page,
+performing a search, or retrieving the results of a search.
+These classes are designed to be small and self-contained, which makes them more stable and easier to maintain.
+
+The `NavigateTo` class is an example of a very simple action class.
+In a larger application, it might have some other methods related to high-level navigation,
+but in our sample project, it just needs to open the DuckDuckGo home page:
 
-The `NavigateTo` class is an example of a very simple action class. In a larger application, it might have some other methods related to high level navigation, but in our sample project, it just needs to open the DuckDuckGo home page:
 ```java
 public class NavigateTo {
 
@@ -145,13 +178,20 @@ public class NavigateTo {
 }
 ```
 
-It does this using a standard Serenity Page Object. Page Objects are often very minimal, storing just the URL of the page itself:
+It does this using a standard Serenity Page Object.
+Page Objects are often very minimal, storing just the URL of the page itself:
+
 ```java
 @DefaultUrl("https://wikipedia.org")
 public class WikipediaHomePage extends PageObject {}
 ```
 
-The second class, `SearchFor`, is an interaction class. It needs to interact with the web page, and to enable this, we make the class extend the Serenity `UIInteractionSteps`. This gives the class full access to the powerful Serenity WebDriver API, including the `$()` method used below, which locates a web element using a `By` locator or an XPath or CSS expression:
+The second class, `SearchFor`, is an interaction class.
+It needs to interact with the web page,
+and to enable this, we make the class extend the Serenity `UIInteractionSteps`.
+This gives the class full access to the powerful Serenity WebDriver API,
+including the `$()` method used below, which locates a web element using a `By` locator or an XPath or CSS expression:
+
 ```java
 public class SearchFor extends UIInteractionSteps {
 
@@ -163,14 +203,21 @@ public class SearchFor extends UIInteractionSteps {
 }
 ```
 
-The `SearchForm` class is typical of a light-weight Page Object: it is responsible uniquely for locating elements on the page, and it does this by defining locators or occasionally by resolving web elements dynamically.
+The `SearchForm` class is typical of a light-weight Page Object:
+it is responsible uniquely for locating elements on the page,
+and it does this by defining locators or occasionally by resolving web elements dynamically.
+
 ```java
 class SearchForm {
     static By SEARCH_FIELD = By.cssSelector("#searchInput");
 }
 ```
 
-The last step library class used in the step definition code is the `SearchResult` class. The job of this class is to query the web page, and retrieve a list of search results that we can use in the AssertJ assertion at the end of the test. This class also extends `UIInteractionSteps` and
+The last step library class used in the step definition code is the `SearchResult` class.
+The job of this class is to query the web page,
+and retrieve a list of search results that we can use in the AssertJ assertion at the end of the test.
+This class also extends `UIInteractionSteps` and
+
 ```java
 public class SearchResult extends UIInteractionSteps {
     public String displayed() {
@@ -180,22 +227,32 @@ public class SearchResult extends UIInteractionSteps {
 ```
 
 The `WikipediaArticle` class is a lean Page Object that locates the article titles on the results page:
+
 ```java
 public class WikipediaArticle {
     public static final By HEADING =  By.id("firstHeading");
 }
 ```
 
-The main advantage of the approach used in this example is not in the lines of code written, although Serenity does reduce a lot of the boilerplate code that you would normally need to write in a web test. The real advantage is in the use of many small, stable classes, each of which focuses on a single job. This application of the _Single Responsibility Principle_ goes a long way to making the test code more stable, easier to understand, and easier to maintain.
+The main advantage of the approach used in this example is not in the lines of code written,
+although Serenity does reduce a lot of the boilerplate code that you would normally need to write in a web test.
+The real advantage is in the use of many small, stable classes, each of which focuses on a single job.
+This application of the _Single Responsibility Principle_ goes a long way to making the test code more stable, easier to understand, and easier to maintain.
 
 ## Executing the tests
-To run the sample project, you can either just run the `CucumberTestSuite` test runner class, or run either `mvn verify` or `gradle test` from the command line.
 
-By default, the tests will run using Chrome. You can run them in Firefox by overriding the `driver` system property, e.g.
+To run the sample project, you can either just run the `CucumberTestSuite` test runner class,
+or run either `mvn verify` or `gradle test` from the command line.
+
+By default, the tests will run using Chrome.
+You can run them in Firefox by overriding the `driver` system property, e.g.
+
 ```json
 $ mvn clean verify -Ddriver=firefox
 ```
+
 Or
+
 ```json
 $ gradle clean test -Pdriver=firefox
 ```
@@ -203,11 +260,16 @@ $ gradle clean test -Pdriver=firefox
 The test results will be recorded in the `target/site/serenity` directory.
 
 ## Generating the reports
-Since the Serenity reports contain aggregate information about all of the tests, they are not generated after each individual test (as this would be extremenly inefficient). Rather, The Full Serenity reports are generated by the `serenity-maven-plugin`. You can trigger this by running `mvn serenity:aggregate` from the command line or from your IDE.
 
-They reports are also integrated into the Maven build process: the following code in the `pom.xml` file causes the reports to be generated automatically once all the tests have completed when you run `mvn verify`?
+Since the Serenity reports contain aggregate information about all of the tests,
+they are not generated after each individual test (as this would be extremenly inefficient).
+Rather, The Full Serenity reports are generated by the `serenity-maven-plugin`.
+You can trigger this by running `mvn serenity:aggregate` from the command line or from your IDE.
 
-```
+They reports are also integrated into the Maven build process:
+the following code in the `pom.xml` file causes the reports to be generated automatically once all the tests have completed when you run `mvn verify`?
+
+```xml
              <plugin>
                 <groupId>net.serenity-bdd.maven.plugins</groupId>
                 <artifactId>serenity-maven-plugin</artifactId>
@@ -228,9 +290,14 @@ They reports are also integrated into the Maven build process: the following cod
 ```
 
 ## Simplified WebDriver configuration and other Serenity extras
-The sample projects both use some Serenity features which make configuring the tests easier. In particular, Serenity uses the `serenity.conf` file in the `src/test/resources` directory to configure test execution options.  
-### Webdriver configuration
+
+The sample projects both use some Serenity features which make configuring the tests easier.
+In particular, Serenity uses the `serenity.conf` file in the `src/test/resources` directory to configure test execution options.  
+
+### WebDriver configuration
+
 The WebDriver configuration is managed entirely from this file, as illustrated below:
+
 ```java
 webdriver {
     driver = chrome
@@ -246,7 +313,11 @@ chrome.switches="""--start-maximized;--test-type;--no-sandbox;--ignore-certifica
 Serenity uses WebDriverManager to download the WebDriver binaries automatically before the tests are executed.
 
 ### Environment-specific configurations
-We can also configure environment-specific properties and options, so that the tests can be run in different environments. Here, we configure three environments, __dev__, _staging_ and _prod_, with different starting URLs for each:
+
+We can also configure environment-specific properties and options,
+so that the tests can be run in different environments.
+Here, we configure three environments, __dev__, _staging_ and _prod_, with different starting URLs for each:
+
 ```json
 environments {
   default {
@@ -264,7 +335,9 @@ environments {
 }
 ```
 
-You use the `environment` system property to determine which environment to run against. For example to run the tests in the staging environment, you could run:
+You use the `environment` system property to determine which environment to run against.
+For example to run the tests in the staging environment, you could run:
+
 ```json
 $ mvn clean verify -Denvironment=staging
 ```
@@ -272,6 +345,7 @@ $ mvn clean verify -Denvironment=staging
 See [**this article**](https://johnfergusonsmart.com/environment-specific-configuration-in-serenity-bdd/) for more details about this feature.
 
 ## Want to learn more?
+
 For more information about Serenity BDD, you can read the [**Serenity BDD Book**](https://serenity-bdd.github.io/theserenitybook/latest/index.html), the official online Serenity documentation source. Other sources include:
 * **[Learn Serenity BDD Online](https://expansion.serenity-dojo.com/)** with online courses from the Serenity Dojo Training Library
 * **[Byte-sized Serenity BDD](https://www.youtube.com/channel/UCav6-dPEUiLbnu-rgpy7_bw/featured)** - tips and tricks about Serenity BDD
diff --git a/build.gradle b/build.gradle
index 2041a32605b2867fcae67c9ab8bc77f9a5f76754..c18fc337f71a9cf0c26b1b2fd4a19f813c3af426 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,56 +1,44 @@
-defaultTasks 'clean', 'test', 'aggregate'
+plugins {
+    id "java"
+    id "eclipse"
+    id "idea"
+    id "net.serenity-bdd.serenity-gradle-plugin" version "4.0.15"
+}
+
+defaultTasks "clean", "test", "aggregate"
 
 repositories {
     mavenCentral()
     mavenLocal()
 }
 
-buildscript {
-    repositories {
-        maven {
-            url "https://plugins.gradle.org/m2/"
-        }
-    }
-    dependencies {
-        classpath "net.serenity-bdd:serenity-gradle-plugin:4.0.15"
-    }
-}
-
-
-apply plugin: 'java'
-apply plugin: 'eclipse'
-apply plugin: 'idea'
-apply plugin: "net.serenity-bdd.serenity-gradle-plugin"
-
-sourceCompatibility = 16
-targetCompatibility = 16
+sourceCompatibility = 17
+targetCompatibility = 17
 
 ext {
-    serenity_version = '4.0.15'
-    junit_platform_launcher_version="1.10.0"
-    cucumber_junit_platform_engine_version="7.14.0"
-    junit_platform_suite_version="1.10.0"
-    junit_jupiter_engine_version="5.9.3"
-    junit_vintage_engine_version="5.9.3"
-    logback_classic_version="1.2.10"
-    assertj_core_version="3.23.1"
+    serenity_version = "4.0.15"
+    junit_platform_launcher_version = "1.10.0"
+    cucumber_junit_platform_engine_version = "7.14.0"
+    junit_platform_suite_version = "1.10.0"
+    junit_jupiter_engine_version = "5.9.3"
+    junit_vintage_engine_version = "5.9.3"
+    logback_classic_version = "1.2.10"
+    assertj_core_version = "3.23.1"
 }
 
 dependencies {
-    dependencies {
-        testImplementation "net.serenity-bdd:serenity-core:${serenity_version}"
-        testImplementation "net.serenity-bdd:serenity-cucumber:${serenity_version}"
-        testImplementation "net.serenity-bdd:serenity-screenplay:${serenity_version}"
-        testImplementation "net.serenity-bdd:serenity-screenplay-webdriver:${serenity_version}"
-        testImplementation "net.serenity-bdd:serenity-ensure:${serenity_version}"
-        testImplementation "org.junit.platform:junit-platform-launcher:${junit_platform_launcher_version}"
-        testImplementation "io.cucumber:cucumber-junit-platform-engine:${cucumber_junit_platform_engine_version}"
-        testImplementation "org.junit.platform:junit-platform-suite:${junit_platform_suite_version}"
-        testImplementation "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_engine_version}"
-        testImplementation "org.junit.vintage:junit-vintage-engine:${junit_vintage_engine_version}"
-        implementation "ch.qos.logback:logback-classic:${logback_classic_version}"
-        testImplementation "org.assertj:assertj-core:${assertj_core_version}"
-    }
+    testImplementation "net.serenity-bdd:serenity-core:${serenity_version}"
+    testImplementation "net.serenity-bdd:serenity-cucumber:${serenity_version}"
+    testImplementation "net.serenity-bdd:serenity-screenplay:${serenity_version}"
+    testImplementation "net.serenity-bdd:serenity-screenplay-webdriver:${serenity_version}"
+    testImplementation "net.serenity-bdd:serenity-ensure:${serenity_version}"
+    testImplementation "org.junit.platform:junit-platform-launcher:${junit_platform_launcher_version}"
+    testImplementation "io.cucumber:cucumber-junit-platform-engine:${cucumber_junit_platform_engine_version}"
+    testImplementation "org.junit.platform:junit-platform-suite:${junit_platform_suite_version}"
+    testImplementation "org.junit.jupiter:junit-jupiter-engine:${junit_jupiter_engine_version}"
+    testImplementation "org.junit.vintage:junit-vintage-engine:${junit_vintage_engine_version}"
+    implementation "ch.qos.logback:logback-classic:${logback_classic_version}"
+    testImplementation "org.assertj:assertj-core:${assertj_core_version}"
 }
 
 test {
diff --git a/pom.xml b/pom.xml
index 9c691feb96e4a7be2811cbf07254f585252b94c8..b13b4ea2efd819837deee7a06c8b90c610f66149 100644
--- a/pom.xml
+++ b/pom.xml
@@ -13,7 +13,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <serenity.version>4.0.15</serenity.version>
         <junit-vintage-engine.version>5.1.0</junit-vintage-engine.version>
-        <junit-platform-suite.version>1.1.0</junit-platform-suite.version>
+        <junit-platform-suite.version>1.10.0</junit-platform-suite.version>
         <cucumber-junit-platform-engine.version>7.14.0</cucumber-junit-platform-engine.version>
         <encoding>UTF-8</encoding>
         <tags></tags>
@@ -133,8 +133,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.8.1</version>
                 <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
+                    <source>17</source>
+                    <target>17</target>
                 </configuration>
             </plugin>
             <plugin>