diff --git a/.github/styles/config/vocabularies/Percona/accept.txt b/.github/styles/config/vocabularies/Percona/accept.txt
index 6476c4ed..0e131f3b 100644
--- a/.github/styles/config/vocabularies/Percona/accept.txt
+++ b/.github/styles/config/vocabularies/Percona/accept.txt
@@ -28,3 +28,5 @@ S3-compatible
 uncomment
 CAs
 Ceph
+Alibaba
+Alibaba Cloud
diff --git a/docs/details/authentication.md b/docs/details/authentication.md
index fa020efa..10287579 100644
--- a/docs/details/authentication.md
+++ b/docs/details/authentication.md
@@ -17,13 +17,13 @@ etc. as the `mongo` shell or `mongodump` command does.
 
      The `pbm-agent` processes should connect to their localhost `mongod` with a standalone type of connection.
 
-     ```{.bash data-prompt="$"}
+     ```bash
      pbm-agent --mongodb-uri "mongodb://pbmuser:secretpwd@localhost:27017/?authSource=admin"
      ```
 
      Alternatively:
 
-     ```{.bash data-prompt="$"} 
+     ```bash 
      export PBM_MONGODB_URI="mongodb://pbmuser:secretpwd@localhost:27017/?authSource=admin"
      pbm-agent
      ```
@@ -32,15 +32,15 @@ etc. as the `mongo` shell or `mongodump` command does.
 
 === "The `pbm` CLI connection string"
 
-     ```{.bash data-prompt="$"}
+     ```bash
      pbm status --mongodb-uri "mongodb://pbmuser:secretpwd@mongocsvr1:27017,mongocsvr2:27017,mongocsvr3:27017/?replicaSet=configrs&authSource=admin"
      ```
 
      Alternatively:
 
-     ```{.bash data-prompt="$"}
+     ```bash
      export PBM_MONGODB_URI="mongodb://pbmuser:secretpwd@mongocsvr1:27017,mongocsvr2:27017,mongocsvr3:27017/?replicaSet=configrs&authSource=admin"
-     $ pbm status
+     pbm status
      ```
      
      Replace the `pbmuser:secretpwd` with the credentials of [the user who owns the pbm process](../install/configure-authentication.md#create-the-pbm-user)
@@ -86,28 +86,28 @@ Specify new values in MongoDB connection URI string as follows:
 
 === "The pbm-agent connection string"    
 
-    ```
+    ```bash
     pbm-agent --mongodb-uri "mongodb://pbmuser:secretpwd@localhost:27017/?authSource=admin&readConcernLevel=local&w=1"
     ```  
 
     Alternatively:    
 
-    ```
+    ```bash
     export PBM_MONGODB_URI="mongodb://pbmuser:secretpwd@localhost:27017/?authSource=admin&readConcernLevel=local&w=1"
     pbm-agent
     ```    
 
 === "The `pbm` CLI connection string"    
 
-    ```{.bash data-prompt="$"}
+    ```bash
     pbm status --mongodb-uri "mongodb://pbmuser:secretpwd@mongocsvr1:27017,mongocsvr2:27017,mongocsvr3:27017/?replicaSet=configrs&authSource=admin&readConcernLevel=local&w=1"
     ```    
 
     Alternatively:    
 
-    ```{.bash data-prompt="$"}
+    ```bash
     export PBM_MONGODB_URI="mongodb://pbmuser:secretpwd@mongocsvr1:27017,mongocsvr2:27017,mongocsvr3:27017/?replicaSet=configrs&authSource=admin&readConcernLevel=local&w=1"
-    $ pbm status
+    pbm status
     ```
 
 Supported values are:
@@ -131,14 +131,14 @@ For [Kerberos authentication :octicons-link-external-16:](https://docs.percona.c
 
 Specify the following string for MongoDB connection URI:
 
-```
+```bash
 PBM_MONGODB_URI="mongodb://<username>%40<KERBEROS_REALM>@<hostname>:27018/?authMechanism=GSSAPI&authSource=%24external&replSetName=xxxx"
 ```
 
 Note that you must first obtain the ticket for the `pbm` user with the `kinit` command before you start the **pbm-agent**:
 
-```{.bash data-prompt="$"}
-$ sudo -u {USER} kinit pbm
+```bash
+sudo -u {USER} kinit pbm
 ```
 
 Note that the `{USER}` is the user that you will run the `pbm-agent` process.
@@ -147,7 +147,7 @@ Note that the `{USER}` is the user that you will run the `pbm-agent` process.
 
 For [authentication and authorization via Native LDAP :octicons-link-external-16:](https://docs.percona.com/percona-server-for-mongodb/latest/authorization.html#authentication-and-authorization-with-direct-binding-to-ldap), you only create roles for LDAP groups in MongoDB as the users are stored and managed on the LDAP server. However, you still define the `$external` database as your authentication source:
 
-```
+```bash
 PBM_MONGODB_URI="mongodb://<user>:<password>@<hostname>:27017/?authMechanism=PLAIN&authSource=%24external&replSetName=xxxx"
 ```
 
@@ -170,7 +170,7 @@ When using [AWS IAM authentication :octicons-link-external-16:](https://docs.per
 
 The MongoDB connection URI string then looks like the following:
 
-```
+```bash
 PBM_MONGODB_URI="mongodb://<aws_access_key_id>:<aws_secret_access_key>@<hostname>:27017/?authMechanism=MONGODB-AWS&authSource=%24external&replSetName=xxxx"
 ```
 
diff --git a/docs/details/azure.md b/docs/details/azure.md
index acc36186..ed86f711 100644
--- a/docs/details/azure.md
+++ b/docs/details/azure.md
@@ -26,32 +26,32 @@ For either method you need a storage account.
     1. Install the [Azure CLI :octicons-link-external-16:](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli). After the installation, the `az` is available for you.
     2. Sign in to Azure CLI:
 
-        ```{.bash data-prompt="$"}
-        $ az login
+        ```bash
+        az login
         ```
 
     3. Create a Resource group if it's not created for you:
 
-        ```{.bash data-prompt="$"}
-        $ az group create --name <your-resource-group> --location <your-location>
+        ```bash
+        az group create --name <your-resource-group> --location <your-location>
         ```
 
         For the list of available locations, run:
 
-        ```{.bash data-prompt="$"}
-        $ az account list-locations
+        ```bash
+        az account list-locations
         ```
 
     4. Create a storage account:
 
-        ```{.bash data-prompt="$"}
-        $ az storage account create --name <storage-account-name> --resource-group <your-resource-group> --location <your-location> --sku Standard_LRS
+        ```bash
+        az storage account create --name <storage-account-name> --resource-group <your-resource-group> --location <your-location> --sku Standard_LRS
         ```
 
     4. Create a blob container:
 
-        ```{.bash data-prompt="$"}
-        $ az storage container create --account-name <storage-account-name> --name <your-container>  --public-access off
+        ```bash
+        az storage container create --account-name <storage-account-name> --name <your-container>  --public-access off
         ```
 
         ??? example "Expected output"
diff --git a/docs/details/gcs.md b/docs/details/gcs.md
index 0b7a0cad..c039551c 100644
--- a/docs/details/gcs.md
+++ b/docs/details/gcs.md
@@ -30,14 +30,14 @@ To use GCS, you need the following:
 
 2. Create a bucket
 
-    ```{.bash data-prompt="$"}
-    $ gcloud storage buckets create my-gcs-bucket --location=US
+    ```bash
+    gcloud storage buckets create my-gcs-bucket --location=US
     ```
       
 3. Verify the bucket creation
 
-    ```{.bash data-prompt="$"}
-    $ gcloud storage buckets list
+    ```bash
+    gcloud storage buckets list
     ```
 
 After the bucket is created, apply the proper [permissions for PBM to use the bucket](storage-configuration.md#permissions-setup).
diff --git a/docs/details/minio.md b/docs/details/minio.md
index 11994f16..1c6b0cfe 100644
--- a/docs/details/minio.md
+++ b/docs/details/minio.md
@@ -12,20 +12,20 @@ This document provides an overview of MinIO as the closest S3-compatible storage
 
 2. Configure the `mc` command line tool with a MinIO Server
 
-    ```{.bash data-prompt="$"}
-    $ mc alias set myminio http://127.0.0.1:9000 MINIO_ACCESS_KEY MINIO_SECRET_KEY
+    ```bash
+    mc alias set myminio http://127.0.0.1:9000 MINIO_ACCESS_KEY MINIO_SECRET_KEY
     ```
     
 3. Create a bucket
 
-    ```{.bash data-prompt="$"}
-    $ mc mb myminio/my-minio-bucket
+    ```bash
+    mc mb myminio/my-minio-bucket
     ```
       
 4. Verify the bucket creation
 
-   ```{.bash data-prompt="$"}
-   $ mc ls myminio
+   ```bash
+   mc ls myminio
    ```
 
 After the bucket is created, apply the proper [permissions for PBM to use the bucket](storage-configuration.md#permissions-setup).
@@ -105,16 +105,16 @@ Let's assume that your custom CA certificate is at `/etc/ssl/minio-ca.crt` path
 
 2. Set the `SSL_CERT_FILE` environment variable to that file's path on each host where `pbm-agent` and PBM CLI are running:
 
-    ```{.bash data-prompt="$"}
-    $ export SSL_CERT_FILE=/etc/ssl/minio-ca.crt
+    ```bash
+    export SSL_CERT_FILE=/etc/ssl/minio-ca.crt
     ```
 
     If this variable isn't set, PBM uses the system root certificates.
 
 3. Restart `pbm-agent`:
 
-    ```{.bash data-prompt="$"}
-    $ sudo systemctl start pbm-agent
+    ```bash
+    sudo systemctl start pbm-agent
     ```
 
 4. Verify that your custom certificate is recognized. Check PBM logs for successful storage access. 
@@ -122,8 +122,8 @@ Let's assume that your custom CA certificate is at `/etc/ssl/minio-ca.crt` path
 
 Alternatively, you can turn off the TLS verification of the S3 storage in Percona Backup for MongoDB configuration:
 
-```{.bash data-prompt="$"}
-$ pbm config --set storage.minio.insecureSkipTLSVerify=True
+```bash
+pbm config --set storage.minio.insecureSkipTLSVerify=True
 ```
 
 !!! warning 
diff --git a/docs/details/oss.md b/docs/details/oss.md
index 5144f542..dae6457c 100644
--- a/docs/details/oss.md
+++ b/docs/details/oss.md
@@ -25,24 +25,24 @@ You can create a bucket via the [Alibaba Cloud Management Console :octicons-link
     1. [Install](https://www.alibabacloud.com/help/en/oss/developer-reference/install-ossutil2#DAS) and configure the Alibaba Cloud OSS client. After the installation, the `ossutil` command line tool is available for you.
     2. Specify the region:
 
-        ```{.bash data-prompt="$"}
-        $ ossutil config
+        ```bash
+        ossutil config
         ```
 
         Press Enter until you see the prompt `Please enter Region [cn-hangzhou]:` and specify the desired region.
 
     3. Create a bucket:
 
-		```{.bash data-prompt="$"}
-		$ ossutil mb oss://your-bucket-name
+		```bash
+		ossutil mb oss://your-bucket-name
 		```
 
 		Replace `your-bucket-name` with the desired name for your bucket.
 
 	4. Verify that the bucket is created:
 
-	 	```{.bash data-prompt="$"}
-		$ ossutil ls
+	 	```bash
+		ossutil ls
 		```
 
 After you created a bucket, apply the [necessary permissions](storage-configuration.md#permissions-setup) for the user identified by the access credentials you plan to use with PBM.
diff --git a/docs/details/s3-storage.md b/docs/details/s3-storage.md
index 90808b4b..3acd9ddb 100644
--- a/docs/details/s3-storage.md
+++ b/docs/details/s3-storage.md
@@ -9,6 +9,7 @@ This document provides overview for the native AWS S3 services. To use MinIO and
 
 [Configuration example :material-arrow-down:](#configuration-example){.md-button}
 
+
 ## Storage bucket creation
 
 To create a bucket, do the following.
@@ -17,14 +18,14 @@ To create a bucket, do the following.
 
 2. Create an S3 bucket
 
-    ```{.bash data-prompt="$"}
-    $ aws s3api create-bucket --bucket my-s3-bucket --region us-east-1
+    ```bash
+    aws s3api create-bucket --bucket my-s3-bucket --region us-east-1
     ```
   
 3. Verify the bucket creation
 
-    ```{.bash data-prompt="$"}
-    $ aws s3 ls
+    ```bash
+    aws s3 ls
     ```
 
 After the bucket is created, apply the proper [permissions for PBM to use the bucket](storage-configuration.md#permissions-setup).
@@ -149,5 +150,59 @@ retryer:
 
 This upload retry increases the chances of data upload completion in cases of unstable connection.
 
+<<<<<<< HEAD
+=======
+## Data upload to storage with self-signed TLS certificates
+
+Percona Backup for MongoDB supports data upload to S3-compatible storage service over HTTPS with a self-signed or a private CA certificate. This feature is especially important when you use services like MinIO, Ceph, or internal S3 gateways that don't use certificates signed by public Certificate Authorities (CAs).
+
+Providing a whole chain of certificates is recommended to ensure the connection is legit. The `SSL_CERT_FILE` environment variable specifies the path to a custom certificate chain file in PEM-format that PBM uses to validate TLS/SSL connection. 
+
+### Usage example
+
+Let's assume that your custom CA certificate is at `/etc/ssl/minio-ca.crt` path and your S3 endpoint is `https://minio.internal.local:9000`. To use self-issued TLS certificates, do the following:
+
+1. Ensure the cert file is in PEM format. Use the following command to check it:
+
+    ```bash
+    cat /etc/ssl/minio-ca.crt
+    ```
+
+    ??? example "Sample output"
+
+
+        ```{text .no-copy}
+        -----BEGIN CERTIFICATE-----
+        MIIC+TCCAeGgAwIBAgIJANH3WljB...
+        -----END CERTIFICATE-----
+        ```
+
+2. Set the `SSL_CERT_FILE` environment variable to that file's path on each host where `pbm-agent` and PBM CLI are running:
+
+    ```bash
+    export SSL_CERT_FILE=/etc/ssl/minio-ca.crt
+    ```
+
+    If this variable isn't set, PBM uses the system root certificates.
+
+3. Restart `pbm-agent`:
+
+    ```bash
+    sudo systemctl start pbm-agent
+    ```
+
+4. Verify that your custom certificate is recognized. Check PBM logs for successful S3 access. 
+
+
+Alternatively, you can disable the TLS verification of the S3 storage in Percona Backup for MongoDB configuration:
+
+```bash
+pbm config --set storage.s3.insecureSkipTLSVerify=True
+```
+
+!!! warning 
+
+    Use this option with caution as it might leave a hole for man-in-the-middle attacks.
+>>>>>>> Removed prompt sign from code blocks
 
 
diff --git a/docs/features/multi-storage.md b/docs/features/multi-storage.md
index f772073e..14657f4c 100644
--- a/docs/features/multi-storage.md
+++ b/docs/features/multi-storage.md
@@ -38,14 +38,14 @@ storage:
 
 To upload the configuration profile to PBM, use the [`pbm profile add`](../reference/pbm-commands.md#pbm-profile-add) command and specify the path to the profile.
 
-```{.bash data-prompt="$"}
-$ pbm profile add <profile_name> /path/to/profile.yaml
+```bash
+pbm profile add <profile_name> /path/to/profile.yaml
 ```
 
 To show the information about the external backup storage, use the [`pbm profile show`](../reference/pbm-commands.md#pbm-profile-show) command:
 
-```{.bash data-prompt="$"}
-$ pbm profile show <profile_name>
+```bash
+pbm profile show <profile_name>
 ```
 
 See the full list of the configuration profile management commands in the [pbm commands](../reference/pbm-commands.md) reference.
@@ -54,8 +54,8 @@ See the full list of the configuration profile management commands in the [pbm c
 
 To make a backup to an external backup storage, pass the profile name with the `--profile` flag for the `pbm backup` command. For example, to run a physical backup and store it in the MinIO storage defined via the `minio` configuration profile, run the following command:
 
-```{.bash data-prompt="$"}
-$ pbm backup -t physical --profile=minio --wait 
+```bash
+pbm backup -t physical --profile=minio --wait 
 ```
 
 ??? example "Sample output"
@@ -76,8 +76,8 @@ Before you start, make sure that `pbm-agents` have the read permissions to backu
 
 1. List backups by running the `pbm list` or `pbm status` commands.
     
-    ```{.bash data-prompt="$"}
-	$ pbm list
+    ```bash
+	pbm list
 	```
 
 	The output shows the backup names and timestamps. External backups are marked with an asterisk:
@@ -96,8 +96,8 @@ Before you start, make sure that `pbm-agents` have the read permissions to backu
 
 2. To make a point-in-time restore, you must explicitly pass the backup name for the `pbm restore` command:
 
-    ```{.bash data-prompt="$"}
-    $ pbm-restore --time=<timestamp> --base-snapshot <backup-name>
+    ```bash
+    pbm-restore --time=<timestamp> --base-snapshot <backup-name>
     ```
 
 3. After the restore is complete, do the required post-restore steps depending on the restore type.
@@ -109,8 +109,8 @@ You can delete backups from an external storage only by name.
 
 Run the `pbm delete` command and pass the backup name:
 
-```{.bash data-prompt="$"}
-$ pbm delete-backup 2024-06-25T10:54:55Z
+```bash
+pbm delete-backup 2024-06-25T10:54:55Z
 ```
 
 ## Implementation specifics
diff --git a/docs/features/physical.md b/docs/features/physical.md
index b4ff1767..abb518b0 100644
--- a/docs/features/physical.md
+++ b/docs/features/physical.md
@@ -156,8 +156,8 @@ To configure physical restores with a fallback directory, use either the PBM con
 
      You can start the restore with a fallback directory directly using the `--fallback-enabled` flag:
 
-     ```{.bash data-prompt="$"}
-     $ pbm restore --time <time> --fallback-enabled=true
+     ```bash
+     pbm restore --time <time> --fallback-enabled=true
      ```
 
 
@@ -172,8 +172,8 @@ A restore can succeed on most nodes, but it might fail on a few, resulting in a
 
 === ":material-console: Command line"
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore --time <time> --fallback-enabled=true --allow-partly-done=true
+    ```bash
+    pbm restore --time <time> --fallback-enabled=true --allow-partly-done=true
     ```
        
 If you allow partial restores (default value), PBM finalizes the restore. Once the cluster is up and running, the failed node receives the necessary data from other members through an initial sync. 
diff --git a/docs/features/point-in-time-recovery.md b/docs/features/point-in-time-recovery.md
index 9b9d51a7..35f267da 100644
--- a/docs/features/point-in-time-recovery.md
+++ b/docs/features/point-in-time-recovery.md
@@ -27,8 +27,8 @@ Set the `pitr.enabled` configuration option to `true`.
 
 === ":octicons-file-code-24: Command line"
 
-     ```{.bash data-prompt="$"}
-     $ pbm config --set pitr.enabled=true
+     ```bash
+     pbm config --set pitr.enabled=true
      ```
 
 === ":material-console: Configuration file"
@@ -87,8 +87,8 @@ You can change the duration of an oplog span via the configuration file. Specify
 
 === ":octicons-file-code-24: Command line"
 
-     ```{.bash data-prompt="$"}
-     $ pbm config --set pitr.oplogSpanMin=5
+     ```bash
+     pbm config --set pitr.oplogSpanMin=5
      ```
 
 === ":material-console: Configuration file"
@@ -157,8 +157,8 @@ The remaining secondaries and the primary nodes in the cluster receive priority
 
 To check the priorities, run the `pbm status` command with the  `--priority` flag.
 
-```{.bash data-prompt="$"}
-$ pbm status --priority
+```bash
+pbm status --priority
 ```
 
 ??? example "Sample output"
@@ -183,8 +183,8 @@ The oplog slices are saved with the `s2` compression method by default. You can
 
 === ":octicons-file-code-24: Command line"
 
-     ```{.bash data-prompt="$"}
-     $ pbm config --set pitr.compression=gzip
+     ```bash
+     pbm config --set pitr.compression=gzip
      ```
 
 === ":material-console: Configuration file"
@@ -214,8 +214,8 @@ The [`pbm list`](../reference/pbm-commands.md#pbm-list) output includes the foll
 * Valid time ranges for recovery
 * Point-in-time recovery status
 
-   ```{.bash data-prompt="$"}
-   $ pbm list
+   ```bash
+   pbm list
 
      2021-08-04T13:00:58Z [restore_to_time: 2021-08-04T13:01:23Z]
      2021-08-05T13:00:47Z [restore_to_time: 2021-08-05T13:01:11Z]
diff --git a/docs/features/restore-remapping.md b/docs/features/restore-remapping.md
index d5b5b89b..bc09fbf9 100644
--- a/docs/features/restore-remapping.md
+++ b/docs/features/restore-remapping.md
@@ -16,26 +16,26 @@ Configure the replica set name mapping:
 
 === ":material-application-variable-outline: Using the environment variable for `pbm` CLI in your shell"
 
-    ```{.bash data-prompt="$"}
-    $ export PBM_REPLSET_REMAPPING="rsTarget1=rsSource1,rsTarget2=rsSource2"
+    ```bash
+    export PBM_REPLSET_REMAPPING="rsTarget1=rsSource1,rsTarget2=rsSource2"
     ``` 
 
     Let's say your source replica sets are `rsA` and `rsB` while the target ones are `rsX` and `rsY`. Then the command to export the environment variable is the following:
 
-    ```{.bash data-prompt="$"}
-    $ export PBM_REPLSET_REMAPPING="rsX=rsA,rsY=rsB"
+    ```bash
+    export PBM_REPLSET_REMAPPING="rsX=rsA,rsY=rsB"
     ``` 
 
 === ":material-console: Using the command line"
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore <timestamp> --replset-remapping="rsTarget1=rsSource1,rsTarget2=rsSource2"
+    ```bash
+    pbm restore <timestamp> --replset-remapping="rsTarget1=rsSource1,rsTarget2=rsSource2"
     ```
 
     Let's say your source replica sets are `rsA` and `rsB` while the target ones are `rsX` and `rsY`. Then the command to run a restore is the following:
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore <timestamp> --replset-remapping="rsX=rsA,rsY=rsB"
+    ```bash
+    pbm restore <timestamp> --replset-remapping="rsX=rsA,rsY=rsB"
     ```
 
     The `--replset-remapping` flag is available for the following commands: `pbm restore`, `pbm list`, `pbm status`, `pbm oplog-replay`. 
diff --git a/docs/features/selective-backup.md b/docs/features/selective-backup.md
index 4f72a57e..2d79fb12 100644
--- a/docs/features/selective-backup.md
+++ b/docs/features/selective-backup.md
@@ -78,8 +78,8 @@ You have a backup and the oplog ranges that fully cover the previous day, 2024-1
 
 To find out the issue, you can restore the `orders` collection under a different name up to the specified time alongside the current `orders` collection and compare them. You decide to restore to 14:00.
 
-```{.bash data-prompt="$"}
-$ pbm restore --time=2024-11-15T14:00:00 --ns-from=goods.orders --ns-to=goods.orders_prev
+```bash
+pbm restore --time=2024-11-15T14:00:00 --ns-from=goods.orders --ns-to=goods.orders_prev
 ```
 
 The `orders_prev` collection has the same data and indexes as the `orders` collection. It also has applied the same oplog operations as the `orders` collection allowing you to see exactly what has changed.
diff --git a/docs/install/backup-storage.md b/docs/install/backup-storage.md
index 92f9c72a..66dc38ba 100644
--- a/docs/install/backup-storage.md
+++ b/docs/install/backup-storage.md
@@ -107,8 +107,8 @@ Percona Backup for MongoDB needs its own dedicated S3 bucket exclusively for bac
 
 3. Apply the config file to PBM
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --file pbm_config.yaml
+    ```bash
+    pbm config --file pbm_config.yaml
     ```
 
 To learn more about Percona Backup for MongoDB configuration, see [Percona Backup for MongoDB configuration in a cluster (or non-sharded replica set)](../reference/config.md).
diff --git a/docs/install/docker.md b/docs/install/docker.md
index 099b8e4a..49971f1d 100644
--- a/docs/install/docker.md
+++ b/docs/install/docker.md
@@ -14,7 +14,7 @@ By default, Docker will pull the image from Docker Hub if it is not available lo
 * [Create the pbm user](configure-authentication.md#create-the-pbm-user) in your deployment. You will need this user credentials to start Percona Backup for MongoDB container. 
 * For physical backups, make sure to use a container that includes both the `mongod` binary as well as the PBM files. Here is an example Dockerfile:
 
-   ```{.bash data-prompt="$"}
+   ```bash
    FROM percona/percona-server-mongodb:latest AS mdb
    FROM percona/percona-backup-mongodb:latest AS pbm 
 
@@ -33,8 +33,8 @@ By default, Docker will pull the image from Docker Hub if it is not available lo
 Start Percona Backup for MongoDB container with the following command:
 
 
-```{.bash data-prompt="$"}
-$ docker run --name <container-name> -e PBM_MONGODB_URI="mongodb://<PBM_USER>:<PBM_USER_PASSWORD>@<HOST>:<PORT>" -d percona/percona-backup-mongodb:<tag>
+```bash
+docker run --name <container-name> -e PBM_MONGODB_URI="mongodb://<PBM_USER>:<PBM_USER_PASSWORD>@<HOST>:<PORT>" -d percona/percona-backup-mongodb:<tag>
 ```
 
 Where:
@@ -51,14 +51,14 @@ Percona Backup for MongoDB requires the remote storage where to store data. Use
 
 1. Start a Bash session:
 	
-    ```{.bash data-prompt="$"}
-    $ docker exec -it <container-name> bash
+    ```bash
+    docker exec -it <container-name> bash
     ```
 
 2. Create a YAML configuration file:
 
-	```{.bash data-prompt="$"}
-	$ vi /tmp/pbm_config.yaml
+	```bash
+	vi /tmp/pbm_config.yaml
 	```
 	
 3. Specify remote storage parameters in the config file. The following example is for S3-compatible backup storage. Check what [other storages are supported](../details/storage-configuration.md):
@@ -76,8 +76,8 @@ Percona Backup for MongoDB requires the remote storage where to store data. Use
 
 4. Upload the config file: 
 	
-	```{.bash data-prompt="$"}
-	$ pbm config --file /tmp/pbm_config.yaml
+	```bash
+	pbm config --file /tmp/pbm_config.yaml
 	```
 
 	The command output displays your uploaded configuration.
@@ -88,8 +88,8 @@ Percona Backup for MongoDB command line utility (`pbm`) provides the set of comm
 
 For example, to start a backup, use the following command:
 
-```{.bash data-prompt="$"}
-$ docker exec -it <container-name> pbm backup
+```bash
+docker exec -it <container-name> pbm backup
 ```
 
 where `<container-name>` is the name you assigned to the container and `pbm backup` is the command to start a backup.
diff --git a/docs/install/repos.md b/docs/install/repos.md
index af1265f0..ca7e3980 100644
--- a/docs/install/repos.md
+++ b/docs/install/repos.md
@@ -21,8 +21,8 @@ Percona provides the [`percona-release` :material-arrow-top-right: ](https://doc
 
 2. Enable the repository    
 
-    ```{.bash data-prompt="$"}
-    $ sudo percona-release enable pbm release
+    ```bash
+    sudo percona-release enable pbm release
     ```
 
 
@@ -32,30 +32,30 @@ Percona provides the [`percona-release` :material-arrow-top-right: ](https://doc
 
     1. Reload the local package database:    
 
-        ```{.bash data-prompt="$"}
-        $ sudo apt update
+        ```bash
+        sudo apt update
         ```    
 
     2. Install Percona Backup for MongoDB:    
 
-        ```{.bash data-prompt="$"}
-        $ sudo apt install percona-backup-mongodb
+        ```bash
+        sudo apt install percona-backup-mongodb
         ```    
 
 === ":material-redhat: On RHEL and derivatives" 
 
     Run the following command to install the packages:
 
-    ```{.bash data-prompt="$"}
-    $ sudo yum install percona-backup-mongodb
+    ```bash
+    sudo yum install percona-backup-mongodb
     ```
 
 === ":fontawesome-brands-amazon: On Amazon Linux 2023"
 
     Run the following command to install the packages:
 
-    ```{.bash data-prompt="$"}
-    $ sudo yum install percona-backup-mongodb
+    ```bash
+    sudo yum install percona-backup-mongodb
     ```
 
 --8<-- "install-result.md"
diff --git a/docs/install/source.md b/docs/install/source.md
index e5356294..169dc955 100644
--- a/docs/install/source.md
+++ b/docs/install/source.md
@@ -22,15 +22,15 @@ Here's how to build Percona Backup for MongoDB:
 
 1. Clone the repository
 
-    ```{.bash data-prompt="$"}
-    $ git clone https://github.com/percona/percona-backup-mongodb
+    ```bash
+    git clone https://github.com/percona/percona-backup-mongodb
     ```
 
 2. Go to the project directory and build it
 
-    ```{.bash data-prompt="$"}
-    $ cd percona-backup-mongodb
-    $ make build
+    ```bash
+    cd percona-backup-mongodb
+    make build
     ```
 
 After **make** completes, you can find `pbm` and `pbm-agent` binaries
@@ -38,9 +38,9 @@ in the `./bin` directory.
 
 3. Check that Percona Backup for MongoDB has been built correctly and is ready for use. 
 
-    ```{.bash data-prompt="$"}
-    $ cd bin
-    $ ./pbm version
+    ```bash
+    cd bin
+    ./pbm version
     ```
 
     ??? example "Output"    
@@ -58,8 +58,8 @@ in the `./bin` directory.
 
         Instead of specifying the path to pbm binaries, you can add it to the PATH environment variable:    
 
-        ```{.bash data-prompt="$"}
-        $ export PATH=/percona-backup-mongodb/bin:$PATH
+        ```bash
+        export PATH=/percona-backup-mongodb/bin:$PATH
         ```
 
 ## Post-install steps
@@ -71,14 +71,14 @@ in the `./bin` directory.
 
      1. Create the environment file:
 
-         ```{.bash data-prompt="$"}
-         $ touch /etc/default/pbm-agent
+         ```bash
+         touch /etc/default/pbm-agent
          ```
 
      2. Create the `pbm-agent.service` systemd unit file.
 
-         ```{.bash data-prompt="$"}
-         $ sudo vim /lib/systemd/system/pbm-agent.service
+         ```bash
+         sudo vim /lib/systemd/system/pbm-agent.service
          ```
 
      3. In the `pbm-agent.service` file, specify the following:
@@ -106,8 +106,8 @@ in the `./bin` directory.
 
      4. Make `systemd` aware of the new service:
 
-         ```{.bash data-prompt="$"}
-         $ sudo systemctl daemon-reload
+         ```bash
+         sudo systemctl daemon-reload
          ```
 
 === ":material-redhat: On Red Hat Enterprise Linux and derivatives"
@@ -117,14 +117,14 @@ in the `./bin` directory.
 
     1. Create the environment file:
    
-        ```{.bash data-prompt="$"}
-        $ touch /etc/sysconfig/pbm-agent
+        ```bash
+        touch /etc/sysconfig/pbm-agent
         ```
 
     2. Create the `pbm-agent.service` systemd unit file.
 
-        ```{.bash data-prompt="$"}
-        $ sudo vim /usr/lib/systemd/system/pbm-agent.service
+        ```bash
+        sudo vim /usr/lib/systemd/system/pbm-agent.service
         ```
 
     3. In the `pbm-agent.service` file, specify the following:
@@ -152,8 +152,8 @@ in the `./bin` directory.
 
      4. Make `systemd` aware of the new service:
 
-         ```{.bash data-prompt="$"}
-         $ sudo systemctl daemon-reload
+         ```bash
+         sudo systemctl daemon-reload
          ```
 
 ## Next steps
diff --git a/docs/install/start-pbm-agent.md b/docs/install/start-pbm-agent.md
index 8d9bf1d4..a8152f76 100644
--- a/docs/install/start-pbm-agent.md
+++ b/docs/install/start-pbm-agent.md
@@ -6,9 +6,9 @@ Start `pbm-agent` on every server with the `mongod` node installed.
 
     We recommend to use the packaged service scripts to run `pbm-agent`.
     
-    ```{.bash data-prompt="$"}
-    $ sudo systemctl start pbm-agent
-    $ sudo systemctl status pbm-agent
+    ```bash
+    sudo systemctl start pbm-agent
+    sudo systemctl status pbm-agent
     ```
 
 === ":fontawesome-solid-user-gear: Manually"
@@ -17,8 +17,8 @@ Start `pbm-agent` on every server with the `mongod` node installed.
 
     The following command starts the `pbm-agent`, redirects the output to a file and puts the process in the background:
     
-    ```{.bash data-prompt="$"}
-    $ su mongod nohup pbm-agent --mongodb-uri "mongodb://username:password@localhost:27018/" > /data/mdb_node_xyz/pbm-agent.$(hostname -s).27018.log 2>&1 &
+    ```bash
+    su mongod nohup pbm-agent --mongodb-uri "mongodb://username:password@localhost:27018/" > /data/mdb_node_xyz/pbm-agent.$(hostname -s).27018.log 2>&1 &
     ```
     
     Replace `username` and `password` with those of your `pbm` user. `/data/mdb_node_xyz/` is the path where `pbm-agent` log files will be written. Make sure you have created this directory and granted write permissions to it for the `mongod` user.
@@ -38,22 +38,22 @@ The steps below show how to achieve this:
 
 1. Set the MongoDB connection string URI for each agent:
 
-    ```{.bash data-prompt="$"}
-    $ tee /etc/sysconfig/pbm-agent1 <<EOF
+    ```bash
+    tee /etc/sysconfig/pbm-agent1 <<EOF
     PBM_MONGODB_URI="mongodb://backupUser:backupPassword@localhost:27018/?authSource=admin"
     EOF
     ```
 
-    ```{.bash data-prompt="$"}
-    $ tee /etc/sysconfig/pbm-agent2 <<EOF
+    ```bash
+    tee /etc/sysconfig/pbm-agent2 <<EOF
     PBM_MONGODB_URI="mongodb://backupUser:backupPassword@localhost:27019/?authSource=admin"
     EOF
     ```
 
 2. Prepare service files for each agent:
 
-    ```{.bash data-prompt="$"}
-    $ tee /usr/lib/systemd/system/pbm-agent1.service <<EOF
+    ```bash
+    tee /usr/lib/systemd/system/pbm-agent1.service <<EOF
     [Unit]
     Description=pbm-agent for mongod1
     After=time-sync.target network.target    
@@ -70,8 +70,9 @@ The steps below show how to achieve this:
     WantedBy=multi-user.target
     EOF
     ```
-    ```{.bash data-prompt="$"}
-    $ tee /usr/lib/systemd/system/pbm-agent2.service <<EOF
+    
+    ```bash
+    tee /usr/lib/systemd/system/pbm-agent2.service <<EOF
     [Unit]
     Description=pbm-agent for mongod2
     After=time-sync.target network.target    
@@ -91,10 +92,10 @@ The steps below show how to achieve this:
 
 3. Reload system units and start `pbm-agent` processes: 
 
-    ```{.bash data-prompt="$"}
-    $ sudo systemctl daemon-reload
-    $ sudo systemctl start pbm-agent1
-    $ sudo systemctl start pbm-agent2
+    ```bash
+    sudo systemctl daemon-reload
+    sudo systemctl start pbm-agent1
+    sudo systemctl start pbm-agent2
     ```
 
 ## How to see the `pbm-agent` log
@@ -103,8 +104,8 @@ With the packaged `systemd` service, the log output to `stdout` is captured by
 systemd’s default redirection to `systemd-journald`. You can view it with the
 command below. See `man journalctl` for useful options such as `--lines`, `--follow`, etc.
 
-```{.bash data-prompt="$"}
-$ journalctl -u pbm-agent.service
+```bash
+journalctl -u pbm-agent.service
 -- Logs begin at Tue {{year}}-01-22 09:31:34 JST. --
 Jan 22 15:59:14 : Started pbm-agent.
 Jan 22 15:59:14 pbm-agent[3579]: pbm agent is listening for the commands
diff --git a/docs/install/tarball.md b/docs/install/tarball.md
index fb2a764e..b13561b1 100644
--- a/docs/install/tarball.md
+++ b/docs/install/tarball.md
@@ -18,22 +18,22 @@ Find the link to the binary tarballs under the **Generic Linux** menu item on [P
 
 1. Fetch the binary tarball. Replace the version in the URL with your required version.
 
-    ```{.bash data-prompt="$"}
-    $ wget https://downloads.percona.com/downloads/percona-backup-mongodb/percona-backup-mongodb-{{release}}/binary/tarball/percona-backup-mongodb-{{release}}-x86_64.tar.gz
+    ```bash
+    wget https://downloads.percona.com/downloads/percona-backup-mongodb/percona-backup-mongodb-{{release}}/binary/tarball/percona-backup-mongodb-{{release}}-x86_64.tar.gz
     ```
 
 2. Extract the tarball
 
-    ```{.bash data-prompt="$"}
-    $ tar -xf percona-backup-mongodb-{{release}}-x86_64.tar.gz
+    ```bash
+    tar -xf percona-backup-mongodb-{{release}}-x86_64.tar.gz
     ```
 
 3. Export the location of the binaries to the `PATH` variable
 
     For example, if you’ve extracted the tarball to your `home` directory, the command would be the following:
 
-    ```{.bash data-prompt="$"}
-    $ export PATH=~/percona-backup-mongodb-{{release}}/:$PATH
+    ```bash
+    export PATH=~/percona-backup-mongodb-{{release}}/:$PATH
     ```
 
 --8<-- "install-result.md"
diff --git a/docs/intro.md b/docs/intro.md
index 830d193c..622a6d69 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -12,20 +12,20 @@ Let's have a look at how Percona Backup for MongoDB works.
 
 With [Percona Backup for MongoDB up and running](installation.md) in your environment, make a backup:
 
-```{.bash data-prompt="$"}
-$ pbm backup --type=logical
+```bash
+pbm backup --type=logical
 ```
 
 To save all events that occurred to the data between backups, enable the point-in-time recovery routine that saves oplog slices:
 
-```{.bash data-prompt="$"}
-$ pbm config --set pitr.enabled=true
+```bash
+pbm config --set pitr.enabled=true
 ```
 
 Now, imagine that your web application’s update was released on February 7 at 03:00 UTC. By 15:23 UTC, someone realizes that this update has a bug that is wiping the historical data of any user who logged in. To remediate this negative impact on data, it’s time to roll back up to the time of the application’s update - up to February 7, 03:00 UTC.
 
-```{.bash data-prompt="$"}
-$ pbm list
+```bash
+pbm list
 ```
 
 ??? admonition "Sample output"
@@ -41,14 +41,14 @@ $ pbm list
 
 The output lists the valid time ranges for the restore. The desired time (February 7, 03:00 UTC) falls within the `2024-02-03T08:08:36Z-2024-02-09T12:20:23Z` range, so let’s restore the database up to that time.
 
-```{.bash data-prompt="$"}
-$ pbm restore --time 2024-02-07T02:59:59
+```bash
+pbm restore --time 2024-02-07T02:59:59
 ```
 
 To be on the safe side, it is a good practice to make a fresh backup after the restore is complete.
 
-```{.bash data-prompt="$"}
-$ pbm backup
+```bash
+pbm backup
 ```
 
 This backup refreshes the timeline and serves as the base for saving oplog slices. The point-in-time recovery routine is re-enabled automatically. It copies the slices taken during the backup and continues oplog slicing from the latest timestamp to ensure oplog continuity.
diff --git a/docs/manage/change-nodes.md b/docs/manage/change-nodes.md
index 4e23c80f..7302538b 100644
--- a/docs/manage/change-nodes.md
+++ b/docs/manage/change-nodes.md
@@ -19,8 +19,8 @@ If you adjusted any of these configurations, here's what you need to do to ensur
 1. Edit the PBM configuration for [node priorities for backups](../usage/backup-priority.md), [oplog slices](../features/point-in-time-recovery.md#adjust-node-priority-for-oplog-slices) or [define custom paths to mongod binaries](../usage/restore-physical.md#define-a-mongod-binary-location) to exclude the node you plan to remove.
 2. Stop `pbm-agent` on the node you plan to remove:
 
-    ```{.bash data-prompt="$"}
-    $ sudo systemctl stop pbm-agent
+    ```bash
+    sudo systemctl stop pbm-agent
     ```
 
     You may see the error like the following in the `pbm status` output on the remaining nodes:
diff --git a/docs/manage/configure-remotely.md b/docs/manage/configure-remotely.md
index b6a757f6..bbe4af6d 100644
--- a/docs/manage/configure-remotely.md
+++ b/docs/manage/configure-remotely.md
@@ -11,24 +11,24 @@ Here’s how to do it:
 1. Create/update the configuration file (for example, `/etc/pbm_config.yaml`)
 2. Create an environment variable for the path to the configuration file
 
-    ```{.bash data-prompt="$"}
-    $ export CONFIG_PATH="/etc/pbm_config.yaml"
+    ```bash
+    export CONFIG_PATH="/etc/pbm_config.yaml"
     ```
 
 3. Pass the configuration file contents to Percona Backup for MongoDB. For example, if you run Percona Backup for MongoDB in Docker, use one of the following commands:
    
     * Connect to the existing container and pass the configuration:
 
-        ```{.bash data-prompt="$"}
-        $ cat "$CONFIG_PATH" | docker compose exec -T $SERVICE_NAME pbm config --file="-"
+        ```bash
+        cat "$CONFIG_PATH" | docker compose exec -T $SERVICE_NAME pbm config --file="-"
         ```
 
         Replace the `$SERVICE_NAME` with your [service name](https://docs.docker.com/compose/compose-file/#services-top-level-element).
 
     * Create a new container to pass the configuration and exit: 
 
-        ```{.bash data-prompt="$"}
-        $ cat "$CONFIG_PATH" | docker run -i --env PBM_MONGODB_URI="mongodb://<PBM_USER>:<PBM_USER_PASSWORD>@<HOST>:<PORT>" --network=$NET_ID $CONTAINER_ID pbm config --file="-"
+        ```bash
+        cat "$CONFIG_PATH" | docker run -i --env PBM_MONGODB_URI="mongodb://<PBM_USER>:<PBM_USER_PASSWORD>@<HOST>:<PORT>" --network=$NET_ID $CONTAINER_ID pbm config --file="-"
         ```
 
         Specify the valid PBM_MONGODB_URI connection string, the ID of the network the container will connect to and the container ID.
diff --git a/docs/manage/logpath.md b/docs/manage/logpath.md
index df41cd6e..b0acfef5 100644
--- a/docs/manage/logpath.md
+++ b/docs/manage/logpath.md
@@ -39,17 +39,17 @@ Start the `pbm-agent` on every node with the following command:
 
 === ":material-console: Command line"
 
-	```{.bash data-prompt="$"}
-	$ pbm-agent --log-path=/var/log/pbm-agent.log --log-level=W --log-json
+	```bash
+	pbm-agent --log-path=/var/log/pbm-agent.log --log-level=W --log-json
 	```
 
 === ":material-variable: Environment variables"
 
-	```{.bash data-prompt="$"}
-	$ export LOG_PATH=/var/log/pbm-agent.log
-	$ export LOG_LEVEL=W
-	$ export LOG_JSON=1
-	$ pbm-agent
+	```bash
+	export LOG_PATH=/var/log/pbm-agent.log
+	export LOG_LEVEL=W
+	export LOG_JSON=1
+	pbm-agent
 	```
 
 === ":octicons-file-code-24: Configuration file"
@@ -65,8 +65,8 @@ Start the `pbm-agent` on every node with the following command:
     
     2. Start the `pbm-agent`:
 
-        ```{.bash data-prompt="$"}
-		$ pbm-agent -f /etc/pbm-agent.yaml
+        ```bash
+		pbm-agent -f /etc/pbm-agent.yaml
 		```
 
 
diff --git a/docs/manage/start-agent-with-config.md b/docs/manage/start-agent-with-config.md
index 745ca893..c61596d0 100644
--- a/docs/manage/start-agent-with-config.md
+++ b/docs/manage/start-agent-with-config.md
@@ -36,8 +36,8 @@ The steps vary slightly based on your installation method. In the following exam
 
 3. Start the `pbm-agent`.
 
-    ```{.bash data-prompt="$"}
-    $ sudo systemctl start pbm-agent
+    ```bash
+    sudo systemctl start pbm-agent
     ```
 
 ## For installation from the source code and tarballs {.power-number}
@@ -59,6 +59,6 @@ For the initial `pbm-agent` start, you require the credentials of a `pbm` user.
 2. Check that you have exported the location of the PBM binaries to the `$PATH` variable
 3. Start the `pbm-agent`:
 
-    ```{.bash data-prompt="$"}
-    $ pbm-agent -f /etc/pbm-agent.yaml
+    ```bash
+    pbm-agent -f /etc/pbm-agent.yaml
 	```
diff --git a/docs/manage/upgrading.md b/docs/manage/upgrading.md
index 2ffa5ff7..3f8dbd30 100644
--- a/docs/manage/upgrading.md
+++ b/docs/manage/upgrading.md
@@ -14,8 +14,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
 2. Enable the repository
 
-    ```{.bash data-prompt="$"}
-    $ sudo percona-release enable pbm release
+    ```bash
+    sudo percona-release enable pbm release
     ```
 
 <i info>:material-information: Note:</i> For `apt`-based systems, run `sudo apt update` to update the local cache.
@@ -29,20 +29,20 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     1. Stop `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl stop pbm-agent
+        ```bash
+        sudo systemctl stop pbm-agent
         ```
 
     2. Install new packages
 
-        ```{.bash data-prompt="$"}
-        $ sudo apt install percona-backup-mongodb
+        ```bash
+        sudo apt install percona-backup-mongodb
         ```  
 
     3. Reload the `systemd` process
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl daemon-reload
+        ```bash
+        sudo systemctl daemon-reload
         ```
 
     4. Update permissions
@@ -52,8 +52,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     5. Start `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl start pbm-agent
+        ```bash
+        sudo systemctl start pbm-agent
         ```
 
 === ":material-redhat: On Red Hat Enterprise Linux and derivatives"
@@ -63,22 +63,22 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     1. Stop `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl stop pbm-agent
+        ```bash
+        sudo systemctl stop pbm-agent
         ```
 
     2. Install new packages
 
-        ```{.bash data-prompt="$"}
-        $ sudo yum install percona-backup-mongodb
+        ```bash
+        sudo yum install percona-backup-mongodb
         ```
 
     3. Reload the `systemd` process
 
        Starting from v1.7.0, reload the `systemd` process to update the unit file with the following command:
 
-       ```{.bash data-prompt="$"}
-       $ sudo systemctl daemon-reload
+       ```bash
+       sudo systemctl daemon-reload
        ```
 
     4. Update permissions
@@ -87,8 +87,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     5. Start `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl start pbm-agent
+        ```bash
+        sudo systemctl start pbm-agent
         ``` 
 
 ## Upgrade to a specific version
@@ -100,8 +100,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     1. List available versions
  
-        ```{.bash data-prompt="$"}
-        $ sudo apt-cache madison percona-backup-mongodb
+        ```bash
+        sudo apt-cache madison percona-backup-mongodb
         ```
 
         ??? example "Sample output"
@@ -115,16 +115,16 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     2. Stop `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl stop pbm-agent
+        ```bash
+        sudo systemctl stop pbm-agent
         ```
 
     3. Install packages
 
         Install a specific version packages. For example, to upgrade to Percona Backup for MongoDB 1.7.0, run the following command:
 
-        ```{.bash data-prompt="$"}
-        $ sudo apt install percona-backup-mongodb=1.7.0-1.stretch
+        ```bash
+        sudo apt install percona-backup-mongodb=1.7.0-1.stretch
         ```
  
     4. Update permissions
@@ -134,8 +134,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     5. Start `pbm-agent`
  
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl start pbm-agent
+        ```bash
+        sudo systemctl start pbm-agent
         ``` 
 
 === ":material-redhat: On Red Hat Enterprise Linux and derivatives"
@@ -145,8 +145,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     1. List available versions
 
-        ```{.bash data-prompt="$"}
-        $ sudo yum list percona-backup-mongodb --showduplicates
+        ```bash
+        sudo yum list percona-backup-mongodb --showduplicates
         ```
 
         ??? example "Sample output"
@@ -163,16 +163,16 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     2. Stop `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl stop pbm-agent
+        ```bash
+        sudo systemctl stop pbm-agent
         ```
 
     3. Install packages
 
         Install a specific version packages. For example, to upgrade to Percona Backup for MongoDB 1.7.1, run the following command:
 
-        ```{.bash data-prompt="$"}
-        $ sudo yum install percona-backup-mongodb-1.7.1-1.el7
+        ```bash
+        sudo yum install percona-backup-mongodb-1.7.1-1.el7
         ```
     
     4. Update permissions
@@ -181,8 +181,8 @@ The recommended and most convenient way to upgrade PBM is from Percona repositor
 
     5. Start `pbm-agent`
 
-        ```{.bash data-prompt="$"}
-        $ sudo systemctl start pbm-agent
+        ```bash
+        sudo systemctl start pbm-agent
         ``` 
 
 <i info>:material-information: Note:</i> If MongoDB runs under a *different user than `mongod`* (the default configuration for Percona Server for MongoDB), use the same user to run the `pbm-agent`. For filesystem-based storage, grant the read / write permissions to the backup directory for this user.
diff --git a/docs/reference/config.md b/docs/reference/config.md
index 351d62bb..5fe6f217 100644
--- a/docs/reference/config.md
+++ b/docs/reference/config.md
@@ -4,8 +4,8 @@ The configuration information is stored in a single document of the `admin.pbmCo
 
 You can see the whole config by running:
 
-```{.javascript  data-prompt=">"}
-> db.getSiblingDB(“admin”).pbmConfig.findOne()
+```javascript
+db.getSiblingDB(“admin”).pbmConfig.findOne()
 ```
 
 But you don’t have to use the `mongo` shell; the `pbm` CLI has a “config” subcommand to read and update it.
@@ -34,8 +34,8 @@ A config file must have a remote backup storage configuration. Find the config f
 
 Use the following command to upload the config file. For example, the config file name is `pbm_config.yaml`:
 
-```{.bash data-prompt="$"}
-$ pbm config --file pbm_config.yaml
+```bash
+pbm config --file pbm_config.yaml
 ```
 
 Execute the command while connecting to the config server replica set if it is a
@@ -79,6 +79,6 @@ Though PBM synchronizes metadata automatically, there are cases when you need to
 
 To sync the metadata, run the following command in the cluster/replica set:
 
-```{.bash data-prompt="$"}
-$ pbm config --force-resync
+```bash
+pbm config --force-resync
 ```
diff --git a/docs/reference/pbm-commands.md b/docs/reference/pbm-commands.md
index 96f94f7c..c0b95dac 100644
--- a/docs/reference/pbm-commands.md
+++ b/docs/reference/pbm-commands.md
@@ -10,8 +10,8 @@ Creates a backup snapshot and saves it in the remote backup storage.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm backup [<flags>]
+```bash
+pbm backup [<flags>]
 ```
 
 For more information about using `pbm backup`, see [Starting a backup](../usage/start-backup.md)
@@ -46,8 +46,8 @@ Closes the `backupCursor` and finishes the external backup. Must be run after ru
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm backup-finish [backup-name] 
+```bash
+pbm backup-finish [backup-name] 
 ```
 
 ## pbm cancel-backup
@@ -74,7 +74,7 @@ Deletes outdated backup snapshots and point-in-time recovery oplog slices.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
+```bash
 pbm cleanup [<flags>]
 ```
 
@@ -95,8 +95,8 @@ Sets, changes or lists Percona Backup for MongoDB configuration.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm config [<flags>] [<key>]
+```bash
+pbm config [<flags>] [<key>]
 ```
 
 The command accepts the following flags:
@@ -158,8 +158,8 @@ Deletes the specified backup snapshot or all backup snapshots that are older tha
 
 The following is the command syntax:
 
-```{.bash data-prompt="$"}
-$ pbm delete-backup [<flags>] [<name>]
+```bash
+pbm delete-backup [<flags>] [<name>]
 ```
 
 The command accepts the following flags:
@@ -178,7 +178,7 @@ Deletes oplog slices produced for Point-in-Time Recovery.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
+```bash
 pbm delete-pitr [<flags>]
 ```
 
@@ -216,8 +216,8 @@ Provides the detailed information about a backup:
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm describe-backup [<backup-name>] [<flags>] 
+```bash
+pbm describe-backup [<backup-name>] [<flags>] 
 ```
 
 | Flag                  | Description                           |
@@ -309,8 +309,8 @@ For **physical backups only**, the following additional information is provided:
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm describe-restore [<restore-timestamp>] [<flags>] 
+```bash
+pbm describe-restore [<restore-timestamp>] [<flags>] 
 ```
 
 The command accepts the following flags:
@@ -409,8 +409,8 @@ Generates the report with the detailed information about a specific backup or a
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm diagnose --path path --name <backup-name> --opid <OPID>
+```bash
+pbm diagnose --path path --name <backup-name> --opid <OPID>
 ```
 
 The command accepts the following flags:
@@ -442,8 +442,8 @@ When Point-in-Time Recovery is enabled, the `pbm list` also provides the list of
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm list [<flags>]
+```bash
+pbm list [<flags>]
 ```
 
 The command accepts the following flags:
@@ -569,8 +569,8 @@ Shows log information from all `pbm-agent` processes.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm logs [<flags>]
+```bash
+pbm logs [<flags>]
 ```
 
 The command accepts the following flags:
@@ -618,8 +618,8 @@ To learn more about the usage, refer to Point-in-Time Recovery oplog replay.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm oplog-replay [<flags>]
+```bash
+pbm oplog-replay [<flags>]
 ```
 
 The command accepts the following flags:
@@ -641,8 +641,8 @@ To learn more about configuration profiles, see [Multiple storages for backups](
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm profile add [<flags>] <profile-name> <path/to/profile.yaml>
+```bash
+pbm profile add [<flags>] <profile-name> <path/to/profile.yaml>
 ``` 
 
 The command accepts the following flags:
@@ -668,8 +668,8 @@ Provides information about [configuration profiles](../features/multi-storage.md
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm profile list [<flags>]
+```bash
+pbm profile list [<flags>]
 ```
 
 The command accepts the following flags:
@@ -703,8 +703,8 @@ Removes the specified configuration profile from PBM.
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm profile remove <profile-name> [<flags>]
+```bash
+pbm profile remove <profile-name> [<flags>]
 ```
 
 The command accepts the following flags:
@@ -729,8 +729,8 @@ Shows the external storage configuration according to the specified configuratio
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm profile show <profile-name> [<flags>]
+```bash
+pbm profile show <profile-name> [<flags>]
 ```
 
 The command accepts the following flags:
@@ -760,8 +760,8 @@ Syncs the backup list from the external storage according to the specified confi
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm profile sync <profile-name> [<flags>]
+```bash
+pbm profile sync <profile-name> [<flags>]
 ```
 
 The command accepts the following flags:
@@ -781,8 +781,8 @@ Restores database from a specified backup / to a specified point in time. Depend
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm restore [<flags>] [<backup_name>]
+```bash
+pbm restore [<flags>] [<backup_name>]
 ```
 
 For more information about using `pbm restore`, see [Restoring a backup](../usage/restore.md).
@@ -832,8 +832,8 @@ Instructs PBM to complete the snapshot-based physical restore. Must be run after
 
 The command has the following syntax:
 
-```{.bash data-prompt="$"}
-$ pbm restore-finish <restore_name> [flags]
+```bash
+pbm restore-finish <restore_name> [flags]
 ```
 
 The command accepts the following flags:
diff --git a/docs/troubleshoot/pbm-report.md b/docs/troubleshoot/pbm-report.md
index 6caab478..1cfa3c00 100644
--- a/docs/troubleshoot/pbm-report.md
+++ b/docs/troubleshoot/pbm-report.md
@@ -17,14 +17,14 @@ This data is stored in separate files in JSON format.
 
 To generate a report, run the `pbm diagnostics` command:
 
-```{.bash data-prompt="$"}
-$ pbm diagnostic --path=path --name=<backup-name> 
+```bash
+pbm diagnostic --path=path --name=<backup-name> 
 ```
 
 or you can use the OPID of the command:
 
-```{.bash data-prompt="$"}
-$ pbm diagnostic --path=path --opid=<OPID> 
+```bash
+pbm diagnostic --path=path --opid=<OPID> 
 ```
 
 where:
@@ -47,8 +47,8 @@ S3 us-east-1 http://minio:9000/mybackups
 
 To retrieve the OpID of the backup operation, run the `pbm describe-backup` command as follows:
 
-```{.bash data-prompt="$"}
-$ pbm describe-backup 2024-11-27T13:49:31Z | grep 'opid'
+```bash
+pbm describe-backup 2024-11-27T13:49:31Z | grep 'opid'
 ```
 
 The output returns the OpID:
@@ -59,14 +59,14 @@ opid: 6747236bfa98f6a85b9bd4e7
 
 Now you can generate the diagnostics report:
 
-```{.bash data-prompt="$"}
-$ pbm diagnostic --path=/tmp/backup_report --opid=6747236bfa98f6a85b9bd4e7
+```bash
+pbm diagnostic --path=/tmp/backup_report --opid=6747236bfa98f6a85b9bd4e7
 ```
 
 Check the generated files:
 
-```{.bash data-prompt="$"}
-$ ls /tmp/backup_report
+```bash
+ls /tmp/backup_report
 6747236bfa98f6a85b9bd4e7.backup.json  6747236bfa98f6a85b9bd4e7.log  6747236bfa98f6a85b9bd4e7.report.json
 ```
 
@@ -74,8 +74,8 @@ You can use the OPID to generate a diagnostics report about other operations lik
 
 You can also output the report into an archive file as follows:
 
-```{.bash data-prompt="$"}
-$ pbm diagnostic --path=path --opid=<OPID> --archive
+```bash
+pbm diagnostic --path=path --opid=<OPID> --archive
 ``` 
 
 The diagnostics report empowers you to collect every necessary aspect for deep analysis of issues with a specific operation, all in one go. If you can't perform the analysis yourself, `pbm diagnostic` offers a quick and convenient way to collect and submit all relevant information for filing a bug report. This significantly reduces the interaction time between you and our experts, accelerating issue resolution.
diff --git a/docs/troubleshoot/status.md b/docs/troubleshoot/status.md
index 165a3681..f49b50fa 100644
--- a/docs/troubleshoot/status.md
+++ b/docs/troubleshoot/status.md
@@ -4,8 +4,8 @@
 
 You can check the status of Percona Backup for MongoDB running in your MongoDB environment using the [`pbm status`](../reference/pbm-commands.md#pbm-status) command.
 
-```{.bash data-prompt="$"}
-$ pbm status
+```bash
+pbm status
 ```
 
 The output provides the information about:
@@ -54,7 +54,6 @@ This simplifies troubleshooting since the whole information is provided in one p
     ========
     S3 us-east-1 https://storage.googleapis.com/backup-test
        Snapshots:
-<<<<<<< PBM-1544-Add-backup-status-to-output
         2025-06-03T09:55:47Z 0.00B <physical> ongoing [running: running / 2025-06-03T09:55:50]
         2025-03-16T10:36:52Z 491.98KB <physical> success [restore_to_time: 2025-03-16T10:37:13]
         2025-03-15T12:59:47Z 284.06KB <physical> success [restore_to_time: 2025-03-15T13:00:08]
@@ -66,19 +65,6 @@ This simplifies troubleshooting since the whole information is provided in one p
         2025-03-11T15:30:38Z 287.07KB <physical> success [restore_to_time: 2025-03-11T15:30:59]
       PITR chunks [1.10MB]:
         2025-03-16T10:37:13 - 2025-03-16T10:43:26 44.17KB
-=======
-         2025-03-16T10:36:52Z 491.98KB [restore_to_time: 2025-03-16T10:37:13]
-         2025-03-15T12:59:47Z 284.06KB [restore_to_time: 2025-03-15T13:00:08]
-         2025-03-15T11:40:46Z 0.00B [canceled: 2025-03-15T11:41:07]
-         2025-03-11T16:23:55Z 284.82KB [restore_to_time: 2025-03-11T16:24:16]
-         2025-03-11T16:22:35Z 284.04KB [restore_to_time: 2025-03-11T16:22:56]
-         2025-03-11T16:21:15Z 283.36KB [restore_to_time: 2025-03-11T16:21:36]
-         2025-03-11T16:19:54Z 281.73KB [restore_to_time: 2025-03-11T16:20:15]
-         2025-03-11T16:19:00Z 281.73KB [restore_to_time: 2025-03-11T16:19:21]
-         2025-03-11T15:30:38Z 287.07KB [restore_to_time: 2025-03-11T15:30:59]
-    PITR chunks:
-         2025-03-16T10:37:13 - 2025-03-16T10:43:26 44.17KB
->>>>>>> main
     ```
 
 ## `pbm-agent` logs
@@ -89,8 +75,8 @@ To troubleshoot issues with specific events or node(s), use the [`pbm logs`](../
 
 `pbm logs` has the set of filters to refine logs for specific events like `backup`, `restore`, `pitr` or for a specific node, and to manage log verbosity level. For example, to view logs about a specific backup with the Debug verbosity level, run the `pbm logs` command as follows:
 
-```{.bash data-prompt="$"}
-$ pbm logs --severity=D --event=backup/2020-10-15T17:42:54Z
+```bash
+pbm logs --severity=D --event=backup/2020-10-15T17:42:54Z
 ```
 
 To learn more about available filters and usage examples, refer to [Viewing backup logs](../usage/logs.md).
@@ -101,22 +87,22 @@ If you have a large logical backup, you can track the backup progress in the log
 
 Start a backup:
 
-```{.bash data-prompt="$"}
-$ pbm backup
+```bash
+pbm backup
 ```
 
 Check backup progress:
 
 1. Check what `pbm-agent` makes the backup:
 
-    ```{.bash data-prompt="$"}
+    ```bash
     pbm logs
     ```
 
 2. Connect to the `mongod` server where the `pbm-agent` is running and check its logs
 
-    ```{.bash data-prompt="$"}
-    $ journalctl -u pbm-agent.service
+    ```bash
+    journalctl -u pbm-agent.service
     ```
 
     ??? example "Sample output"
diff --git a/docs/troubleshoot/troubleshooting.md b/docs/troubleshoot/troubleshooting.md
index 21d1946d..48b9e50c 100644
--- a/docs/troubleshoot/troubleshooting.md
+++ b/docs/troubleshoot/troubleshooting.md
@@ -17,8 +17,8 @@ Run **pbm-speed-test** for the full set of available commands.
 
 ### Compression test
 
-```{.bash data-prompt="$"}
-$ pbm-speed-test compression --compression=s2 --size-gb 10
+```bash
+pbm-speed-test compression --compression=s2 --size-gb 10
 ```
 
 ??? example "Sample output"
@@ -38,30 +38,34 @@ To test compression on a real collection, pass the
 
 Run `pbm-speed-test compression --help` for the full set of supported flags:
 
-```{.bash data-prompt="$"}
-$ pbm-speed-test compression --help
-usage: pbm-speed-test compression
-
-Run compression test
-
-Flags:
-      --help                     Show context-sensitive help (also try
-                                 --help-long and --help-man).
-      --mongodb-uri=MONGODB-URI  MongoDB connection string
-  -c, --sample-collection=SAMPLE-COLLECTION
-                                 Set collection as the data source
-  -s, --size-gb=SIZE-GB          Set data size in GB. Default 1
-      --compression=s2           Compression type
-                                 <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>
-      --compression-level=COMPRESSION-LEVEL
-                                 Compression level (specific to the compression type)
-                                 <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>
+```bash
+pbm-speed-test compression --help
 ```
 
+??? example "Sample output"
+
+    ```{.text .no-copy}
+    usage: pbm-speed-test compression
+
+    Run compression test
+
+    Flags:
+          --help                     Show context-sensitive help (also try
+                                     --help-long and --help-man).
+          --mongodb-uri=MONGODB-URI  MongoDB connection string
+      -c, --sample-collection=SAMPLE-COLLECTION
+                                     Set collection as the data source
+      -s, --size-gb=SIZE-GB          Set data size in GB. Default 1
+          --compression=s2           Compression type
+                                     <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>
+          --compression-level=COMPRESSION-LEVEL
+                                     Compression level (specific to the compression type)
+                                     <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>
+
 ### Upload speed test
 
-```{.bash data-prompt="$"}
-$ pbm-speed-test storage --compression=s2
+```bash
+pbm-speed-test storage --compression=s2
 ```
 
 ??? example "Sample output"
@@ -81,21 +85,25 @@ pass the `--sample-collection` flag with the `<my_db.my_collection>` value.
 
 Run `pbm-speed-test storage --help` for the full set of available flags:
 
+```bash
+pbm-speed-test storage --help
 ```
-$ pbm-speed-test storage --help
-usage: pbm-speed-test storage
-
-Run storage test
-
-Flags:
-      --help                     Show context-sensitive help (also try --help-long and --help-man).
-      --mongodb-uri=MONGODB-URI  MongoDB connection string
-  -c, --sample-collection=SAMPLE-COLLECTION
-                                 Set collection as the data source
-  -s, --size-gb=SIZE-GB          Set data size in GB. Default 1
-      --compression=s2           Compression type <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>
-      --compression-level=COMPRESSION-LEVEL
-                                Compression level (specific to the compression type)
-```
+
+??? example "Sample output"
+
+    ```{.text .no-copy}
+    usage: pbm-speed-test storage
+
+    Run storage test
+
+    Flags:
+          --help                     Show context-sensitive help (also try --help-long and --help-man).
+          --mongodb-uri=MONGODB-URI  MongoDB connection string
+      -c, --sample-collection=SAMPLE-COLLECTION
+                                     Set collection as the data source
+      -s, --size-gb=SIZE-GB          Set data size in GB. Default 1
+          --compression=s2           Compression type <none>/<gzip>/<snappy>/<lz4>/<s2>/<pgzip>/<zstd>
+          --compression-level=COMPRESSION-LEVEL
+                                    Compression level (specific to the compression type)
 
 
diff --git a/docs/usage/backup-external.md b/docs/usage/backup-external.md
index 00fca941..c3ee3e6e 100644
--- a/docs/usage/backup-external.md
+++ b/docs/usage/backup-external.md
@@ -6,8 +6,8 @@
 
 1. To make a snapshot-based backup, run the [`pbm backup`](../reference/pbm-commands.md#pbm-backup) command with the type `external`:
 
-    ```{.bash data-prompt="$"}
-    $ pbm backup -t external 
+    ```bash
+    pbm backup -t external 
     ```    
 
     When executing the command, PBM does the following:    
@@ -30,8 +30,8 @@
 
 4. After the copy/snapshot is complete, run the following command to close the `$backupCursor` and finish the backup: 
 
-    ```{.bash data-prompt="$"}
-    $ pbm backup-finish <backup_name>
+    ```bash
+    pbm backup-finish <backup_name>
     ```
 
 ## Next steps
diff --git a/docs/usage/backup-incremental.md b/docs/usage/backup-incremental.md
index b78cf33a..5f7b8693 100644
--- a/docs/usage/backup-incremental.md
+++ b/docs/usage/backup-incremental.md
@@ -6,16 +6,16 @@
 
 1. To start incremental backups, first make a full incremental backup. It will serve as the base for subsequent incremental backups:
 
-    ```{.bash data-prompt="$"} 
-    $ pbm backup --type incremental --base
+    ```bash 
+    pbm backup --type incremental --base
     ```
 
     The `pbm-agent` starts tracking the incremental backup history to be able to calculate and save the difference in data blocks. 
 
 2. Run regular incremental backups:
 
-    ```{.bash data-prompt="$"}
-    $ pbm backup --type incremental
+    ```bash
+    pbm backup --type incremental
     ```
 
 The incremental backup history looks like this:
diff --git a/docs/usage/backup-physical.md b/docs/usage/backup-physical.md
index c3d76de0..62f21db5 100644
--- a/docs/usage/backup-physical.md
+++ b/docs/usage/backup-physical.md
@@ -8,8 +8,8 @@ During a *physical* backup, Percona Backup for MongoDB  copies the contents of t
 
 To start a backup, run the following command:
 
-```{.bash data-prompt="$"}
-$ pbm backup --type=physical
+```bash
+pbm backup --type=physical
 ```
      
 !!! warning 
diff --git a/docs/usage/backup-selective.md b/docs/usage/backup-selective.md
index 3152c973..3ad9b659 100644
--- a/docs/usage/backup-selective.md
+++ b/docs/usage/backup-selective.md
@@ -10,14 +10,14 @@ Before you start, read about [selective backups known limitations](../features/k
 
 To make a selective backup, run the `pbm backup` command and provide the value for the `--ns` flag in the format `<database.collection>`. The `--ns` flag value is case sensitive. For example, to back up the "Payments" collection, run the following command:
 
-```{.bash data-prompt="$"}
-$ pbm backup --ns=customers.payments
+```bash
+pbm backup --ns=customers.payments
 ```
 
 To back up the "Invoices" database and all collections that it includes, run the ``pbm backup`` command as follows:
 
-```{.bash data-prompt="$"}
-$ pbm backup --ns=invoices.*
+```bash
+pbm backup --ns=invoices.*
 ```
 
 To back up multiple namespaces, specify them as a comma-separated list for the `--ns` flag: `<db1.col1>`,`<db2.*>`,`<db3.collX>`. The number of namespaces to specify is unlimited.
diff --git a/docs/usage/cancel-backup.md b/docs/usage/cancel-backup.md
index 3bfef7c8..c734ed05 100644
--- a/docs/usage/cancel-backup.md
+++ b/docs/usage/cancel-backup.md
@@ -5,19 +5,19 @@ another maintenance of a server and don’t want to wait for the large backup to
 
 To cancel the backup, use the [`pbm cancel-backup`](../reference/pbm-commands.md#pbm-cancel-backup) command.
 
-```{.bash data-prompt="$"}
-$ pbm cancel-backup
+```bash
+pbm cancel-backup
 Backup cancellation has started
 ```
 
 After the command execution, the backup is marked as canceled in the [pbm status](../troubleshoot/status.md) output:
 
-```{.bash data-prompt="$"}
-$ pbm status
+```bash
+pbm status
 ```
 
 **Output**:
 
-```{.bash .no-copy}
+```{.text .no-copy}
 2020-04-30T18:05:26Z  Canceled at 2020-04-30T18:05:37Z
 ```
\ No newline at end of file
diff --git a/docs/usage/compression.md b/docs/usage/compression.md
index 78b40f32..950177ee 100644
--- a/docs/usage/compression.md
+++ b/docs/usage/compression.md
@@ -6,8 +6,8 @@ You can start a backup with a different compression method by passing the `--com
 
 For example, to start a backup with `gzip` compression, use the following command:
 
-```{.bash data-prompt="$"}
-$ pbm backup --compression=gzip
+```bash
+pbm backup --compression=gzip
 ```
 
 Supported compression types are: `gzip`, `snappy`, `lz4`, `pgzip`, `zstd`.  The `none` value means no compression is done during backup.
diff --git a/docs/usage/delete-backup.md b/docs/usage/delete-backup.md
index 3fefe027..e3f564d3 100644
--- a/docs/usage/delete-backup.md
+++ b/docs/usage/delete-backup.md
@@ -16,8 +16,8 @@ The timestamp you specify for the `--older-than` flag must be in the following f
 
 During the cleanup, you see the backups and oplog slices to be deleted and are asked to confirm the action. To bypass it, add the `--yes` flag:
 
-```{.bash data-prompt="$"}
-$ pbm cleanup --older-than=`%Y-%M-%D --yes
+```bash
+pbm cleanup --older-than=`%Y-%M-%D --yes
 ```
 
 ### Behavior
@@ -42,15 +42,15 @@ Here's how the cleanup works:
 
     You wish to delete all backups that are older than 2023-04-14T15:00:00
 
-    ```{.bash .no-copy}
-    $ pbm cleanup --older-than="2023-04-14T15:00:00"
+    ```bash
+    pbm cleanup --older-than="2023-04-14T15:00:00"
     ```
 
     This timestamp falls inside the backup chain that starts with the `2023-04-14T08:12:50Z` backup. That’s why PBM keeps this backup and the incremental backup chain deriving from it and deletes all data that is older than this backup.
 
     ??? example "Sample output"    
 
-        ```{.bash .no-copy} 
+        ```{.text .no-copy} 
         S3 us-east-1 s3://http://192.168.56.1:9000/bcp/pbme2etest
           Snapshots:
             2023-04-14T19:34:52Z 520.86MB <incremental> [restore_to_time: 2023-04-14T19:34:54Z]
@@ -63,7 +63,7 @@ Here's how the cleanup works:
 
        To illustrate, let's say you have the following backup list:
 
-       ```{.bash .no-copy}
+       ```{.text .no-copy}
        Snapshots:
            2023-04-13T13:26:58Z 147.29MB <logical> [restore_to_time: 2023-04-13T13:27:15Z]
            2023-04-13T10:12:08Z 147.29MB <logical> [restore_to_time: 2023-04-13T10:12:27Z]
@@ -78,7 +78,7 @@ Here's how the cleanup works:
 
        Sample output:
 
-       ```{.bash .no-copy}
+       ```{.text .no-copy}
        Snapshots:
            2023-04-13T13:26:58Z 147.29MB <logical> [restore_to_time: 2023-04-13T13:27:15Z]
            2023-04-13T10:12:08Z 147.29MB <logical> [restore_to_time: 2023-04-13T10:12:27Z]
@@ -143,8 +143,8 @@ You can delete either a specified backup snapshot or all backup snapshots older
 
      To delete a backup, specify the `<backup_name>` as an argument.
 
-     ```{.bash data-prompt="$"}
-     $ pbm delete-backup <backup_name>
+     ```bash
+     pbm delete-backup <backup_name>
      ```
 
 === "Backups older than the specified time"
@@ -158,8 +158,8 @@ You can delete either a specified backup snapshot or all backup snapshots older
 
     View backups:
 
-    ```{.bash data-prompt="$"}
-    $ pbm list
+    ```bash
+    pbm list
     ```
 
     ??? example "Sample output"
@@ -174,7 +174,7 @@ You can delete either a specified backup snapshot or all backup snapshots older
 
     Delete backups created before the specified timestamp
 
-    ```{.bash data-prompt="$"}
+    ```bash
     pbm delete-backup -f --older-than 2021-04-21
     ```
 
@@ -243,8 +243,8 @@ You can delete either a specified backup snapshot or all backup snapshots older
 By default, the ``pbm delete-backup`` command asks for your confirmation to proceed with the deletion. To bypass it, add the `-y` or
  `--yes` flag.
 
- ```{.bash data-prompt="$"}
- $ pbm delete-backup --yes 2023-04-20T13:45:59Z
+ ```bash
+ pbm delete-backup --yes 2023-04-20T13:45:59Z
  ```
 
 !!! admonition ""
@@ -269,8 +269,8 @@ To view oplog slices, run the [`pbm list`](../reference/pbm-commands.md#pbm-list
 
     Run the `pbm delete-pitr` and pass the `--all` flag:
 
-    ```{.bash data-prompt="$"}
-    $ pbm delete-pitr --all
+    ```bash
+    pbm delete-pitr --all
     ```
 
 === "Earlier than the specified timestamp" 
@@ -280,8 +280,8 @@ To view oplog slices, run the [`pbm list`](../reference/pbm-commands.md#pbm-list
     * `%Y-%M-%DT%H:%M:%S` (for example, 2021-07-20T10:01:18) or
     * `%Y-%M-%D` (2021-07-20).
 
-    ```{.bash data-prompt="$"}
-    $ pbm delete-pitr --older-than 2021-07-20T10:01:18
+    ```bash
+    pbm delete-pitr --older-than 2021-07-20T10:01:18
     ```
 
 To enable [point-in-time recovery](pitr-tutorial.md) from the most recent backup snapshot, Percona Backup for MongoDB does not delete slices that were made after that snapshot. For example, if the most recent snapshot is `2021-07-20T07:05:23Z [restore_to_time: 2021-07-21T07:05:44]` and you specify the timestamp `2021-07-20T07:05:44`, Percona Backup for MongoDB deletes only slices that were made before `2021-07-20T07:05:23Z`.
diff --git a/docs/usage/describe-backup.md b/docs/usage/describe-backup.md
index 7f33b566..77527e82 100644
--- a/docs/usage/describe-backup.md
+++ b/docs/usage/describe-backup.md
@@ -2,8 +2,8 @@
 
 To view a detailed information about a backup, run the following command:
 
-```{.bash data-prompt="$"}
-$ pbm describe-backup <backup-name>
+```bash
+pbm describe-backup <backup-name>
 ```
 
 The output provides the backup name, type, status, size and the information about the cluster topology it was taken in. For [selective backups](../features/selective-backup.md), it also shows the namespaces that were backed up. 
@@ -59,8 +59,8 @@ You can view the list of collections included in the *logical* or *selective* ba
 
 To view the backup contents, use the `--with-collections` flag:
 
-```{.bash data-prompt="$"}
-$ pbm describe-backup <backup-name> --with-collections
+```bash
+pbm describe-backup <backup-name> --with-collections
 ```
 
 ??? example "Sample output"
diff --git a/docs/usage/list-backup.md b/docs/usage/list-backup.md
index 6ad44793..a6db0422 100644
--- a/docs/usage/list-backup.md
+++ b/docs/usage/list-backup.md
@@ -2,8 +2,8 @@
 
 Use the `pbm list` command to view all completed backups. 
 
-```{.bash data-prompt="$"}
-$ pbm list
+```bash
+pbm list
 ```
 
 The output provides the following information:
diff --git a/docs/usage/logs.md b/docs/usage/logs.md
index f2bbb337..8f5d66b1 100644
--- a/docs/usage/logs.md
+++ b/docs/usage/logs.md
@@ -32,20 +32,20 @@ The following are some examples of filtering logs:
 
 **Show logs for all backups**
 
-```{.bash data-prompt="$"}
-$ pbm logs --event=backup
+```bash
+pbm logs --event=backup
 ```
 
 **Show the last 100 lines of the log about a specific backup 2020-10-15T17:42:54Z**
 
-```{.bash data-prompt="$"}
-$ pbm logs --tail=100 --event=backup/2020-10-15T17:42:54Z
+```bash
+pbm logs --tail=100 --event=backup/2020-10-15T17:42:54Z
 ```
 
 **Include only errors from the specific replica set**
 
-```{.bash data-prompt="$"}
-$ pbm logs -n rs1 -s E
+```bash
+pbm logs -n rs1 -s E
 ```
 
 The output includes log messages of the specified severity type and all higher levels. Thus, when `ERROR` is specified, both `ERROR` and `FATAL` messages are shown in the output.
diff --git a/docs/usage/oplog-replay.md b/docs/usage/oplog-replay.md
index 848349b8..325b9fbd 100644
--- a/docs/usage/oplog-replay.md
+++ b/docs/usage/oplog-replay.md
@@ -30,8 +30,8 @@ After you [restored a physical backup](restore.md), do the following:
 
 3. Run the `pbm oplog-replay` command and specify the `--start` and `--end` flags with the timestamps.
 
-    ```{.bash data-prompt="$"}
-    $ pbm oplog-replay --start="2022-01-02T15:00:00" --end="2022-01-03T15:00:00"
+    ```bash
+    pbm oplog-replay --start="2022-01-02T15:00:00" --end="2022-01-03T15:00:00"
     ```
 
 4. After the oplog replay, make a fresh backup and enable the point-in-time recovery oplog slicing.
@@ -48,8 +48,8 @@ Storage-level snapshots are saved with point-in-time recovery enabled. Thus, aft
 3. Re-sync the data from the storage.
 4. Run the `pbm oplog-replay` command and specify the `--start` and `--end` flags with the timestamps.
 
-    ```{.bash data-prompt="$"}
-    $ pbm oplog-replay --start="2022-01-02T15:00:00" --end="2022-01-03T15:00:00"
+    ```bash
+    pbm oplog-replay --start="2022-01-02T15:00:00" --end="2022-01-03T15:00:00"
     ```
 
 5. After the oplog replay, make a fresh backup and enable the point-in-time recovery oplog slicing.
diff --git a/docs/usage/pitr-physical.md b/docs/usage/pitr-physical.md
index 2df6d774..21e0e80d 100644
--- a/docs/usage/pitr-physical.md
+++ b/docs/usage/pitr-physical.md
@@ -10,8 +10,8 @@ You can recover your database from a full or an incremental physical backup in t
 
 To restore a database from a physical backup, specify the time for the [`pbm restore`](../reference/pbm-commands.md#pbm-restore) command:    
 
-```{.bash data-prompt="$"}
-$ pbm restore --time <timestamp> 
+```bash
+pbm restore --time <timestamp> 
 ```    
 
 Percona Backup for MongoDB recognizes if it is a full or an incremental backup and restores the database from it up to the specified time.     
@@ -23,8 +23,8 @@ You can [track the restore progress](restore-progress.md) using the `pbm describ
 
     For PBM versions earlier than 2.3.0, the command for the point-in-time recovery is the following:
         
-    ```{.bash data-prompt="$"}
-    $ pbm restore --base-snapshot=<backup_name> --time <timestamp>
+    ```bash
+    pbm restore --base-snapshot=<backup_name> --time <timestamp>
     ```
 
     The `--base-snapshot` flag is required. Otherwise, PBM will look for a logical backup even if there is none or there is a more recent physical backup.    
@@ -39,8 +39,8 @@ After the point-in-time recovery is complete, perform these post-restore steps:
 
 3. Resync the backup list with the storage:    
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --force-resync
+    ```bash
+    pbm config --force-resync
     ```    
 
 4. Start the balancer and start `mongos` nodes.    
diff --git a/docs/usage/pitr-selective.md b/docs/usage/pitr-selective.md
index a7c4539b..43066ca7 100644
--- a/docs/usage/pitr-selective.md
+++ b/docs/usage/pitr-selective.md
@@ -12,8 +12,8 @@
 
 2. To restore the desired database or a collection to a point in time, run the ``pbm restore`` command as follows:
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore --base-snapshot <backup_name> --time <timestamp> \
+    ```bash
+    pbm restore --base-snapshot <backup_name> --time <timestamp> \
     --ns <db.collection>
     ```
 
diff --git a/docs/usage/pitr-tutorial.md b/docs/usage/pitr-tutorial.md
index 20f97038..fb823a4f 100644
--- a/docs/usage/pitr-tutorial.md
+++ b/docs/usage/pitr-tutorial.md
@@ -6,15 +6,15 @@
 
 Run [`pbm restore`](../reference/pbm-commands.md#pbm-restore) and specify the timestamp from the valid range:    
 
-```{.bash data-prompt="$"}
-$ pbm restore --time="2022-12-14T14:27:04"
+```bash
+pbm restore --time="2022-12-14T14:27:04"
 ```    
 
 The timestamp you specify for the restore must be within the time ranges in the PITR section of `pbm list` output. Percona Backup for MongoDB automatically selects the most recent backup among logical, physical and incremental in relation to the specified timestamp and uses that as the base for the restore.    
 
 To illustrate this behavior, let’s use the following `pbm list` output as the example.     
 
-```{.bash .no-copy}
+```{.text .no-copy}
 $ pbm list    
 
   2025-03-04T13:00:58Z [restore_to_time: 2025-03-04T13:01:23]
@@ -43,14 +43,14 @@ A restore operation changes the time line of oplog events. Therefore, all oplog
 
 1. Make a new backup to serve as the starting point for oplog updates:    
 
-    ```{.bash data-prompt="$"}
-    $ pbm backup
+    ```bash
+    pbm backup
     ```    
 
 2. Re-enable point-in-time recovery to resume saving oplog slices:    
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --set pitr.enabled=true
+    ```bash
+    pbm config --set pitr.enabled=true
     ```
 
 ## Select a backup snapshot for the restore
diff --git a/docs/usage/restore-external.md b/docs/usage/restore-external.md
index a5df123d..e6eddd2a 100644
--- a/docs/usage/restore-external.md
+++ b/docs/usage/restore-external.md
@@ -15,8 +15,8 @@ The following procedure describes the restore process from backups [made through
 
 1. To perform a restore, run the following command:
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore --external 
+    ```bash
+    pbm restore --external 
     ```    
 
     Percona Backup for MongoDB stops the database, cleans up data directories on all nodes, provides the restore name and prompts you to copy the data:    
@@ -32,8 +32,8 @@ The following procedure describes the restore process from backups [made through
 
 3. After you copied the files to the nodes, complete the restore with the following command:    
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore-finish <restore_name> -c </path/to/pbm-conf.yaml>
+    ```bash
+    pbm restore-finish <restore_name> -c </path/to/pbm-conf.yaml>
     ```    
 
     At this stage, Percona Backup for MongoDB reads the metadata from the backup, prepares the data for the cluster / replica set start and ensures its consistency. The database is restored to the timestamp specified in the `restore_to_time` of the metadata.
@@ -42,8 +42,8 @@ The following procedure describes the restore process from backups [made through
 
         If you use a filesystem as the remote backup storage, both `pbm-agent` and `pbm` CLI must have the same permissions to it. To achieve this, run the `pbm restore-finish` command as the `mongod` user:
 
-        ```{.bash data-prompt="$"}
-        $ sudo -u mongod -s pbm restore-finish <restore_name> -c </path/to/pbm-conf.yaml> --mongodb-uri=MONGODB_URI
+        ```bash
+        sudo -u mongod -s pbm restore-finish <restore_name> -c </path/to/pbm-conf.yaml> --mongodb-uri=MONGODB_URI
         ```
 
 4. Optional. You can track the restore progress by running the [`pbm describe-restore`](../reference/pbm-commands.md#pbm-describe-restore) command.
@@ -58,8 +58,8 @@ After the restore is complete, do the following:
 
 3. Run the following command to resync the backup list with the storage:
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --force-resync
+    ```bash
+    pbm config --force-resync
     ``` 
 
 4. Start the balancer and start `mongos` nodes.
@@ -97,8 +97,8 @@ To restore from a backup, do the following:
 
 1. Start a restore
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore --external -c </path/to/mongod.conf> --ts 
+    ```bash
+    pbm restore --external -c </path/to/mongod.conf> --ts 
     ```
 
     If the path to the source cluster `mongod.conf` is undefined, PBM tries to retrieve the required configuration options from the `mongod.conf` of the target cluster.    
@@ -109,8 +109,8 @@ To restore from a backup, do the following:
 
 3. Complete the restore by running:
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore-finish <restore_name> -c </path/to/pbm.conf.yaml>
+    ```bash
+    pbm restore-finish <restore_name> -c </path/to/pbm.conf.yaml>
     ```    
 
     At this stage, Percona Backup for MongoDB prepares the data for the cluster / replica set start and ensures its consistency. 
@@ -119,8 +119,8 @@ To restore from a backup, do the following:
 
         If you use a filesystem as the remote backup storage, both `pbm-agent` and `pbm` CLI must have the same permissions to it. To achieve this, run the `pbm restore-finish` command as the `mongod` user:
 
-        ```{.bash data-prompt="$"}
-        $ sudo -u mongod -s pbm restore-finish <restore_name> -c </path/to/pbm-conf.yaml> --mongodb-uri=MONGODB_URI
+        ```bash
+        sudo -u mongod -s pbm restore-finish <restore_name> -c </path/to/pbm-conf.yaml> --mongodb-uri=MONGODB_URI
         ```
 
 4. Don't forget to complete the [post-restore steps](#post-restore-steps).
diff --git a/docs/usage/restore-incremental.md b/docs/usage/restore-incremental.md
index 73260531..b6dbab26 100644
--- a/docs/usage/restore-incremental.md
+++ b/docs/usage/restore-incremental.md
@@ -13,7 +13,7 @@
 1. Shut down all `mongos` nodes, `pmm-agent` processes and clients that can do writes to the database as it won’t be available while the restore is in progress.
 2. Check that the `systemctl` restart policy for the `pbm-agent.service` is not set to `always` or `on-success`:
 
-    ```{.bash data-prompt="$"}
+    ```bash
     sudo systemctl show pbm-agent.service | grep Restart
     ```
 
@@ -30,8 +30,8 @@
 
 Restore flow from an incremental backup is the same as the restore from a full physical backup: specify the backup name for the `pbm restore` command:
 
-```{.bash data-prompt="$"}
-$ pbm restore 2022-11-25T14:13:43Z
+```bash
+pbm restore 2022-11-25T14:13:43Z
 ```
 
 Percona Backup for MongoDB recognizes the backup type, finds the base incremental backup, restores the data from it and then restores the modified data from applicable incremental backups.
diff --git a/docs/usage/restore-physical.md b/docs/usage/restore-physical.md
index f467ee0b..ae2d1ea7 100644
--- a/docs/usage/restore-physical.md
+++ b/docs/usage/restore-physical.md
@@ -6,8 +6,8 @@
 
 1. Disable point-in-time recovery. A restore and point-in-time recovery oplog slicing are incompatible operations and cannot be run simultaneously. 
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --set pitr.enabled=false
+    ```bash
+    pbm config --set pitr.enabled=false
     ```
 
 2. The Percona Server for MongoDB version for both backup and restore data must be within the same major release.
@@ -21,9 +21,9 @@
 3. Stop the arbiter nodes manually since there's no `pbm-agent` on these nodes to do that automatically.
 4. Check that the `systemctl` restart policy for the `pbm-agent.service` and `mongod.service` processes is not set to `always` or `on-success`:
 
-    ```{.bash data-prompt="$"}
-    $ sudo systemctl show mongod.service | grep Restart
-    $ sudo systemctl show pbm-agent.service | grep Restart
+    ```bash
+    sudo systemctl show mongod.service | grep Restart
+    sudo systemctl show pbm-agent.service | grep Restart
     ```
 
     ??? example "Sample output"
@@ -39,14 +39,14 @@
 
 1. List the backups 
 
-    ```{.bash data-prompt="$"}
-    $ pbm list
+    ```bash
+    pbm list
     ```
 
 2. Make a restore
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore <backup_name>
+    ```bash
+    pbm restore <backup_name>
     ```
 
     During the physical restore, `pbm-agent` processes stop the `mongod` nodes, clean up the data directory and copy the data from the storage onto every node. During this process, the database is restarted several times. 
@@ -76,8 +76,8 @@ After the restore is complete, do the following:
 
 4. Run the following command to resync the backup list with the storage:
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --force-resync -w
+    ```bash
+    pbm config --force-resync -w
     ``` 
 
 5. Start the balancer and start `mongos` nodes.
@@ -101,8 +101,8 @@ During physical restores, Percona Backup for MongoDB performs several restarts o
 
 === ":material-console: Command line"
 
-    ```{.bash data-prompt="$"}
-    $ pbm config --set restore.mongodLocation=/path/to/mongod/
+    ```bash
+    pbm config --set restore.mongodLocation=/path/to/mongod/
     ```
 
 If you have different paths to `mongod` binaries on every node of your cluster / replica set, use the `mongodLocationMap` option to specify your custom paths for each node.
diff --git a/docs/usage/restore-progress.md b/docs/usage/restore-progress.md
index 23a798c5..6866a42f 100644
--- a/docs/usage/restore-progress.md
+++ b/docs/usage/restore-progress.md
@@ -6,8 +6,8 @@ You can track the status of both physical and logical restores. This gives you a
 
 To view the restore status, run the `pbm describe-restore` command and specify the restore name. To track a physical restore progress, specify the path to the Percona Backup for MongoDB (PBM) configuration file. Since `mongod` nodes are shut down during a physical restore, Percona Backup for MongoDB uses the configuration file to read the restore status on storage. PBM stores the restore metadata only in the main storage when [multiple backup storages](../features/multi-storage.md) are configured. 
 
-```{.bash data-prompt="$"}
-$ pbm describe-restore 2022-08-15T11:14:55.683148162Z -c pbm_config.yaml
+```bash
+pbm describe-restore 2022-08-15T11:14:55.683148162Z -c pbm_config.yaml
 ```
 
 The output provides the following information:
diff --git a/docs/usage/restore-selective.md b/docs/usage/restore-selective.md
index fa609f4b..8450f9db 100644
--- a/docs/usage/restore-selective.md
+++ b/docs/usage/restore-selective.md
@@ -10,13 +10,14 @@ You can restore a specific database or a collection either from a full or a sele
 
 1. List the backups
 
-    ```{.bash data-prompt="$"}
-    $ pbm list
+    ```bash
+    pbm list
     ```
+    
 2. Run the ``pbm restore`` command in the format:
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore <backup_name> --ns <database.collection>
+    ```bash
+    pbm restore <backup_name> --ns <database.collection>
     ```
 
  You can specify several namespaces as a comma-separated list for the `--ns` flag: `<db1.col1>,<db2.*>`. For example, `--ns=customers.payments,invoices.*`.
@@ -27,8 +28,8 @@ During the restore, Percona Backup for MongoDB retrieves the file for the specif
 
 To restore a [custom database with users and roles](../features/selective-backup.md#restore-a-database-with-users-and-roles) from a full backup, add the `--with-users-and-roles` flag to the `pbm restore` command:
 
-```{.bash data-prompt="$"}
-$ pbm restore <backup_name> --ns <database.*> --with-users-and-roles
+```bash
+pbm restore <backup_name> --ns <database.*> --with-users-and-roles
 ```
 
 ### Restore a collection under a different name
@@ -39,16 +40,16 @@ Note that in version 2.8.0 you can restore a single collection and this collecti
 
 To restore a collection, pass the collection name from the backup for the `--ns-from` flag and the new name for the `--ns-to` flag:
 
-```{.bash data-prompt="$"}
-$ pbm restore <backup_name> --ns-from <database.collection> --ns-to <database.collection_new>
+```bash
+pbm restore <backup_name> --ns-from <database.collection> --ns-to <database.collection_new>
 ```
 
 The new collection has the same data and indexes as the source collection. You must provide a unique name for the collection you restore, otherwise the restore fails.
 
 You can restore a collection under a new name up to the specified time. Instead of the backup name, specify the timestamp, the source collection name and the new name as follows:
 
-```{.bash data-prompt="$"}
-$ pbm restore --time=<timestamp> --ns-from <database.collection> --ns-to <database.collection_new>
+```bash
+pbm restore --time=<timestamp> --ns-from <database.collection> --ns-to <database.collection_new>
 ```
 
 ## Post-restore steps
diff --git a/docs/usage/restore.md b/docs/usage/restore.md
index fe718a01..a86e31d5 100644
--- a/docs/usage/restore.md
+++ b/docs/usage/restore.md
@@ -13,8 +13,8 @@
 
 1. Stop the balancer and disable chunks autosplit. To verify that both are disabled, run the following command:
 
-    ```{.javascript data-prompt=">"}
-    > sh.status() 
+    ```javascript
+     sh.status() 
     ```
 
     You should see the following output:
@@ -37,15 +37,15 @@
 
 1. List the backups to restore from
 
-    ```{.bash data-prompt="$"}
-    $ pbm list
+    ```bash
+    pbm list
     ```
 
 
 2. Restore from a desired backup. Replace the `<backup_name>` with the desired backup in the following command:
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore <backup_name>
+    ```bash
+    pbm restore <backup_name>
     ```
 
     Note that you can restore a sharded backup only into a sharded environment. It can be your existing cluster or a new one. To learn how to restore a backup into a new environment, see [Restoring a backup into a new environment](../features/restore-new-env.md).
@@ -73,8 +73,8 @@ The default values were adjusted to fit the setups with the memory allocation of
 
 Starting with version 2.8.0, you can override the number of insertion workers per collection and the number of collections to process in parallel during a logical restore. For example:
 
-```{.bash data-prompt="$"}
-$ pbm restore <backup_name>  --num-insertion-workers-per-collection 4 --num-parallel-collections 8
+```bash
+pbm restore <backup_name>  --num-insertion-workers-per-collection 4 --num-parallel-collections 8
 ```
 
 Increasing the number may increase the restore speed. However, it may also lead to unexpectedly high disk and CPU usage. Consider the trade-offs carefully before making adjustments to ensure optimal performance without overloading resources.
@@ -94,8 +94,8 @@ The following example illustrates the restore from a backup made on Percona Serv
 
 1. Check the FCV value for the backup
 
-    ```{.bash data-prompt="$"}
-    $ pbm status
+    ```bash
+    pbm status
     ```
 
     ??? admonition "Sample output"
@@ -107,20 +107,20 @@ The following example illustrates the restore from a backup made on Percona Serv
 
 2. Set the Feature Compatibility Version value to 4.4
 
-    ```{.javascript data-prompt=">"}
-    > db.adminCommand( { setFeatureCompatibilityVersion: "4.4" } )
+    ```javascript
+    db.adminCommand( { setFeatureCompatibilityVersion: "4.4" } )
     ```
 
 3. Restore the database
 
-    ```{.bash data-prompt="$"}
-    $ pbm restore 2023-04-10T10:51:28Z
+    ```bash
+    pbm restore 2023-04-10T10:51:28Z
     ```
 
 4. Set the Feature Compatibility Version value to 5.0
 
-    ```{.javascript data-prompt=">"}
-    > db.adminCommand( { setFeatureCompatibilityVersion: "5.0" } )
+    ```javascript
+    db.adminCommand( { setFeatureCompatibilityVersion: "5.0" } )
     ```
 
 ## Next steps
diff --git a/docs/usage/schedule-backup.md b/docs/usage/schedule-backup.md
index 899a7555..dd84057c 100644
--- a/docs/usage/schedule-backup.md
+++ b/docs/usage/schedule-backup.md
@@ -6,8 +6,8 @@ We recommend using `crond` or similar services to schedule backup snapshots.
 
     Before configuring `crond`, make sure that you have [installed](../installation.md) and [configured](../install/initial-setup.md) Percona Backup for MongoDB to make backups in your database. Start a backup manually to verify this: 
 
-    ```{.bash data-prompt="$"}
-    $ pbm backup
+    ```bash
+    pbm backup
     ```
 
 The recommended approach is to create a `crontab` file in the `/etc/cron.d` directory and specify the command in it. This simplifies server administration especially if multiple users have access to it.
@@ -23,21 +23,21 @@ The steps are the following:
 
     === ":material-debian: Debian and Ubuntu"
 
-        ```{.bash data-prompt="$"}
-        $ vim /etc/default/pbm-cron
+        ```bash
+        vim /etc/default/pbm-cron
         ``` 
 
     === ":material-redhat: Red Hat Enterprise Linux and derivatives"
 
-        ```{.bash data-prompt="$"}
-        $ vim /etc/sysconfig/pbm-cron
+        ```bash
+        vim /etc/sysconfig/pbm-cron
         ```
 
 
 2. Specify the environment variable in `pbm-cron`:
     
-     ```{.bash data-prompt="$"}
-     $ export PBM_MONGODB_URI="mongodb://pbmuser:secretpwd@localhost:27017/?replSetName=xxxx"
+     ```bash
+     export PBM_MONGODB_URI="mongodb://pbmuser:secretpwd@localhost:27017/?replSetName=xxxx"
      ```
 
 3. Grant access to the `pbm-cron` file for the user that will execute the `cron` task.
@@ -45,13 +45,13 @@ The steps are the following:
 
 4. Create a `crontab` file. Let’s name it `pbm-backup`.
 
-     ```{.bash data-prompt="$"}
-     $ touch pbm-backup
+     ```bash
+     touch pbm-backup
      ```
 
 5. Specify the command in the file:
 
-     ```{.bash data-prompt="$"}
+     ```bash
      30 23 * * sun <user-to-execute-cron-task> . /etc/default/pbm-cron; /usr/bin/pbm backup
      ```
 
@@ -62,8 +62,8 @@ The steps are the following:
 
 6. Verify that backups are running in `/var/log/cron` or `/var/log/syslog` logs:
 
-     ```{.bash data-prompt="$"}
-     $ grep CRON /var/log/syslog
+     ```bash
+     grep CRON /var/log/syslog
      ```
 
 ## Schedule backups with point-in-time recovery running
@@ -88,8 +88,8 @@ Starting with version 2.1.0, you can use the [`pbm cleanup --older-than`](../ref
 
 You can configure a `cron` task to automate storage cleanup by specifying the following command in the `crontab` file:
 
-```{.bash data-prompt="$"}
-$ /usr/bin/pbm cleanup -y --older-than 30d --wait
+```bash
+/usr/bin/pbm cleanup -y --older-than 30d --wait
 ``` 
 
 This command deletes backups and oplog slices that are older than 30 days. You can change the period by specifying a desired interval for the `--older-than` flag. 
@@ -99,8 +99,8 @@ This command deletes backups and oplog slices that are older than 30 days. You c
 
     For PBM version 2.0.5 and earlier, use the [`pbm delete backup --older-than <timestamp>`](../reference/pbm-commands.md#pbm-delete-backup) command. You can configure a `cron` task to automate backup deletion by specifying the following command in the `crontab` file:
 
-    ```{.bash data-prompt="$"}
-    $ /usr/bin/pbm delete-backup -f --older-than $(date -d '-1 month' +\%Y-\%m-\%d) 
+    ```bash
+    /usr/bin/pbm delete-backup -f --older-than $(date -d '-1 month' +\%Y-\%m-\%d) 
     ```
 
     This command deletes backups that are older than 30 days. You can change the period by specifying a desired interval for the `date` function.
diff --git a/docs/usage/start-backup.md b/docs/usage/start-backup.md
index 86a05cac..f9e94707 100644
--- a/docs/usage/start-backup.md
+++ b/docs/usage/start-backup.md
@@ -11,8 +11,8 @@
 
 To make a backup, run the following command:
 
-```{.bash data-prompt="$"}
-$ pbm backup --type=logical
+```bash
+pbm backup --type=logical
 ```
      
 Logical backup is the default one so you can bypass the `--type` flag. 
diff --git a/mkdocs-base.yml b/mkdocs-base.yml
index 80075f19..598d99b0 100644
--- a/mkdocs-base.yml
+++ b/mkdocs-base.yml
@@ -127,6 +127,10 @@ plugins:
   git-revision-date-localized:
     enable_creation_date: true
     enabled: !ENV [ENABLED_GIT_REVISION_DATE, True]
+  git-committers:
+    enabled: !ENV [CI, false]
+    repository: percona/psmdb-docs
+    branch: "main"
   tags: {}
   glightbox: {}
   open-in-new-tab: {}
diff --git a/requirements.txt b/requirements.txt
index 28917048..82a0e22c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -18,3 +18,4 @@ mike
 mkdocs-open-in-new-tab
 Pillow > 10.1.0
 mkdocs-print-site-plugin
+mkdocs-git-committers-plugin-2