diff --git a/binaries/build.py b/binaries/build.py
index da196da9556..39f3e0234a7 100644
--- a/binaries/build.py
+++ b/binaries/build.py
@@ -1,6 +1,8 @@
 import argparse
 import glob
 import os
+import shlex
+import subprocess
 import sys
 
 # To help discover local modules
@@ -49,10 +51,12 @@ def build_dist_whl(args):
         print(f"## In directory: {os.getcwd()} | Executing command: {cur_wheel_cmd}")
 
         if not args.dry_run:
-            build_exit_code = os.system(cur_wheel_cmd)
-            # If any one of the steps fail, exit with error
-            if build_exit_code != 0:
-                sys.exit(f"## {binary} build Failed !")
+            try:
+                cur_wheel_cmd_list = shlex.split(cur_wheel_cmd)
+                subprocess.run(cur_wheel_cmd_list, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            except subprocess.CalledProcessError as e:
+                print(f"## {binary} build Failed! Error: {e.stderr.decode()}")
+                sys.exit(1)
 
 
 def build(args):
diff --git a/binaries/conda/build_packages.py b/binaries/conda/build_packages.py
index 00b9e9c13b3..5f5e1e54c23 100644
--- a/binaries/conda/build_packages.py
+++ b/binaries/conda/build_packages.py
@@ -1,19 +1,16 @@
 import argparse
 import os
+import subprocess
 from datetime import date
 
-from ts_scripts.utils import try_and_handle
+from ts_scripts.utils import try_and_handle, find_conda_binary
 
 conda_build_dir = os.path.dirname(os.path.abspath(__file__))
 REPO_ROOT = os.path.join(conda_build_dir, "..", "..")
 MINICONDA_DOWNLOAD_URL = (
     "https://repo.anaconda.com/miniconda/Miniconda3-py39_4.9.2-Linux-x86_64.sh"
 )
-CONDA_BINARY = (
-    os.popen("which conda").read().strip()
-    if os.system(f"conda --version") == 0
-    else f"$HOME/miniconda/condabin/conda"
-)
+CONDA_BINARY = find_conda_binary()
 
 CONDA_PACKAGES_PATH = os.path.join(REPO_ROOT, "binaries", "conda", "output")
 CONDA_LINUX_PACKAGES_PATH = os.path.join(
@@ -32,8 +29,7 @@
 
 if os.name == "nt":
     # Assumes miniconda is installed in windows
-    CONDA_BINARY = "conda"
-
+    CONDA_BINARY = "conda"    
 
 def add_nightly_suffix_conda(binary_name: str) -> str:
     """
@@ -52,15 +48,15 @@ def install_conda_build(dry_run):
     """
 
     # Check if conda binary already exists
-    exit_code = os.system(f"conda --version")
-    if exit_code == 0:
-        print(
-            f"'conda' already present on the system. Proceeding without a fresh conda installation."
-        )
+    try:
+        subprocess.run(["conda", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("'conda' already present on the system. Proceeding without a fresh conda installation.")
         return
-    try_and_handle(
-        f"{CONDA_BINARY} install python=3.8 conda-build anaconda-client -y", dry_run
-    )
+    except subprocess.CalledProcessError:
+        # Conda is not available, proceed with installation
+        try_and_handle(
+            f"{CONDA_BINARY} install python=3.8 conda-build anaconda-client -y", dry_run
+        )
 
 
 def install_miniconda(dry_run):
@@ -68,13 +64,13 @@ def install_miniconda(dry_run):
     Installs miniconda, a slimmer anaconda installation to build conda packages
     """
 
-    # Check if conda binary already exists
-    exit_code = os.system(f"conda --version")
-    if exit_code == 0:
-        print(
-            f"'conda' already present on the system. Proceeding without a fresh minconda installation."
-        )
+    try:
+        subprocess.run(["conda", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        print("'conda' already present on the system. Proceeding without a fresh conda installation.")
         return
+    except subprocess.CalledProcessError as e:
+        raise (e)
+
     if os.name == "nt":
         print(
             "Identified as Windows system. Please install miniconda using this URL: https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe"
diff --git a/binaries/install.py b/binaries/install.py
index 04b151eb7cd..05fbaccb9db 100644
--- a/binaries/install.py
+++ b/binaries/install.py
@@ -1,4 +1,5 @@
 import os
+import subprocess
 import sys
 import glob
 
@@ -13,19 +14,25 @@ def install():
     if is_conda_env():
         print("## Using conda to install torchserve and torch-model-archiver")
         channel_dir = os.path.abspath(os.path.join(REPO_ROOT, "binaries", "conda", "output"))
-        conda_cmd = f"conda install --channel {channel_dir} -y torchserve torch-model-archiver"
-        print(f"## In directory: {os.getcwd()} | Executing command: {conda_cmd}")
-        install_exit_code = os.system(conda_cmd)
+        conda_cmd = ["conda", "install", "--channel", channel_dir, "-y", "torchserve", "torch-model-archiver"]
+        print(f"## In directory: {os.getcwd()} | Executing command: {' '.join(conda_cmd)}")
+        
+        try:
+            subprocess.run(conda_cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        except subprocess.CalledProcessError as e:
+            sys.exit("## Torchserve/Model archiver Installation Failed!")
+
     else:
         print("## Using pip to install torchserve and torch-model-archiver")
         ts_wheel = glob.glob(os.path.join(REPO_ROOT, "dist", "*.whl"))[0]
         ma_wheel = glob.glob(os.path.join(REPO_ROOT, "model-archiver", "dist", "*.whl"))[0]
-        pip_cmd = f"pip install {ts_wheel} {ma_wheel}"
-        print(f"## In directory: {os.getcwd()} | Executing command: {pip_cmd}")
-        install_exit_code = os.system(pip_cmd)
+        pip_cmd = ["pip", "install", ts_wheel, ma_wheel]
+        print(f"## In directory: {os.getcwd()} | Executing command: {' '.join(pip_cmd)}")
 
-    if install_exit_code != 0:
-        sys.exit("## Torchserve \ Model archiver Installation Failed !")
+        try:
+            subprocess.run(pip_cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        except subprocess.CalledProcessError as e:
+            sys.exit("## Torchserve/Model archiver Installation Failed!")
 
 
 if __name__ == "__main__":
diff --git a/binaries/upload.py b/binaries/upload.py
index 328f104b672..618da6a5515 100755
--- a/binaries/upload.py
+++ b/binaries/upload.py
@@ -3,6 +3,7 @@
 import glob
 import os
 import sys
+import subprocess
 
 # To help discover local modules
 REPO_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
@@ -44,11 +45,17 @@ def upload_conda_packages(args, PACKAGES, CONDA_PACKAGES_PATH):
                 "tar.bz2"
             ):
                 print(f"Uploading to anaconda package: {name}")
-                anaconda_upload_command = f"anaconda upload {file_path} --force"
-                exit_code = os.system(anaconda_upload_command)
-                if exit_code != 0:
-                    print(f"Anaconda package upload failed for package {name}")
-                    return exit_code
+                anaconda_upload_command = ["anaconda", "upload", file_path, "--force"]
+
+                try:
+                    subprocess.run(
+                        anaconda_upload_command,
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE
+                    )
+                except subprocess.CalledProcessError as e:
+                    return e.returncode
     print(f"All packages uploaded to anaconda successfully")
 
 
diff --git a/examples/image_classifier/near_real_time_video/create_mar_file.py b/examples/image_classifier/near_real_time_video/create_mar_file.py
index 8c56642b051..c276811b21e 100644
--- a/examples/image_classifier/near_real_time_video/create_mar_file.py
+++ b/examples/image_classifier/near_real_time_video/create_mar_file.py
@@ -5,6 +5,7 @@
 import argparse
 import os
 import shutil
+import subprocess
 
 MODEL_PTH_FILE = "resnet18-f37072fd.pth"
 MODEL_STORE = "model_store"
@@ -15,7 +16,7 @@ def download_pth_file(output_file: str) -> None:
     if not os.path.exists(output_file):
         cmd = ["wget", " https://download.pytorch.org/models/resnet18-f37072fd.pth"]
         print("Downloading resnet-18 pth file")
-        os.system(" ".join(cmd))
+        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
 
 def create_mar():
@@ -42,9 +43,8 @@ def create_mar():
             "--handler image_classifier",
             "--force",
         ]
-
     print(f"Archiving resnet-18 model into {MAR_FILE}")
-    os.system(" ".join(cmd))
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
 
 def move_mar_file():
diff --git a/examples/torchrec_dlrm/create_dlrm_mar.py b/examples/torchrec_dlrm/create_dlrm_mar.py
index 7d1722b0dca..dc5ed3752ae 100644
--- a/examples/torchrec_dlrm/create_dlrm_mar.py
+++ b/examples/torchrec_dlrm/create_dlrm_mar.py
@@ -2,8 +2,7 @@
 This script creates a DLRM model and packs it into a TorchServe mar file
 """
 
-import os
-
+import subprocess
 import torch
 from dlrm_factory import DLRMFactory
 
@@ -32,7 +31,7 @@ def main():
     ]
 
     print("Archiving model into dlrm.mar")
-    os.system(" ".join(cmd))
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     print("Done")
 
 
diff --git a/test/pytest/test_distributed_inference_handler.py b/test/pytest/test_distributed_inference_handler.py
index b5ab178e5d3..e810e6d3d90 100644
--- a/test/pytest/test_distributed_inference_handler.py
+++ b/test/pytest/test_distributed_inference_handler.py
@@ -1,6 +1,6 @@
 import os
 import sys
-
+import subprocess
 import pytest
 import test_utils
 
@@ -37,10 +37,14 @@ def test_large_model_inference():
     )
 
     try:
-        command = f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_INFERENCE} -d {POSTMAN_LARGE_MODEL_INFERENCE_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_INFERENCE_DIR}/{REPORT_FILE} --verbose"
-        result = os.system(command)
+        command = [
+            "newman", "run", "-e", POSTMAN_ENV_FILE, POSTMAN_COLLECTION_INFERENCE,
+            "-d", POSTMAN_LARGE_MODEL_INFERENCE_DATA_FILE, "-r", "cli,htmlextra",
+            "--reporter-htmlextra-export", f"{ARTIFACTS_INFERENCE_DIR}/{REPORT_FILE}", "--verbose"
+        ]
+        result = subprocess.run(command, check=True)
         assert (
-            result == 0
+            result.returncode == 0
         ), "Error: Distributed inference failed, the exit code is not zero"
     finally:
         test_utils.stop_torchserve()
diff --git a/test/pytest/test_handler.py b/test/pytest/test_handler.py
index eea6461534f..5014409f7d6 100644
--- a/test/pytest/test_handler.py
+++ b/test/pytest/test_handler.py
@@ -2,7 +2,7 @@
 import json
 import logging
 import os
-
+import subprocess
 import numpy as np
 import pytest
 import requests
@@ -314,10 +314,14 @@ def test_huggingface_bert_batch_inference():
 
     # Make 2 curl requests in parallel with &
     # curl --header \"X-Forwarded-For: 1.2.3.4\" won't work since you can't access local host anymore
-    response = os.popen(
-        f"curl http://127.0.0.1:8080/predictions/BERTSeqClassification -T {input_text} & curl http://127.0.0.1:8080/predictions/BERTSeqClassification -T {input_text}"
-    )
-    response = response.read()
+    curl_command = [
+        "curl", "http://127.0.0.1:8080/predictions/BERTSeqClassification", "-T", input_text
+    ]
+    process1 = subprocess.Popen(curl_command, stdout=subprocess.PIPE)
+    process2 = subprocess.Popen(curl_command, stdout=subprocess.PIPE)
+    response1, _ = process1.communicate()
+    response2, _ = process2.communicate()
+    response = response1.decode() + response2.decode()
 
     ## Assert that 2 responses are returned from the same batch
     assert response == "Not AcceptedNot Accepted"
@@ -360,7 +364,7 @@ def test_MMF_activity_recognition_model_register_and_inference_on_valid_model():
 
 def test_huggingface_bert_model_parallel_inference():
     number_of_gpus = torch.cuda.device_count()
-    check = os.popen(f"curl http://localhost:8081/models")
+    check = subprocess.run(["curl", "http://localhost:8081/models"], capture_output=True, text=True)
     print(check)
     if number_of_gpus > 1:
         batch_size = 1
@@ -385,10 +389,12 @@ def test_huggingface_bert_model_parallel_inference():
             "sample_text_captum_input.txt",
         )
 
-        response = os.popen(
-            f"curl http://127.0.0.1:8080/predictions/Textgeneration -T {input_text}"
+        response = subprocess.run(
+            ["curl", "http://127.0.0.1:8080/predictions/Textgeneration", "-T", input_text],
+            capture_output=True,
+            text=True
         )
-        response = response.read()
+        response = response.stdout
 
         assert (
             "Bloomberg has decided to publish a new report on the global economy"
diff --git a/test/pytest/test_sm_mme_requirements.py b/test/pytest/test_sm_mme_requirements.py
index 14d40fee242..d49e159123f 100644
--- a/test/pytest/test_sm_mme_requirements.py
+++ b/test/pytest/test_sm_mme_requirements.py
@@ -1,6 +1,6 @@
 import os
 import pathlib
-
+import subprocess
 import pytest
 import requests
 import test_utils
@@ -103,25 +103,24 @@ def test_oom_on_invoke():
 
     # Make 8 curl requests in parallel with &
     # Send multiple requests to make sure to hit OOM
+    processes = []
     for i in range(10):
-        response = os.popen(
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} && "
-            f"curl http://127.0.0.1:8080/models/BERTSeqClassification/invoke -T {input_text} "
-        )
-        response = response.read()
+        for _ in range(8):
+            process = subprocess.Popen(
+                ["curl", "http://127.0.0.1:8080/models/BERTSeqClassification/invoke", "-T", input_text],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            processes.append(process)
+    responses = []
+    for process in processes:
+        stdout, stderr = process.communicate()
+        responses.append(stdout.decode())
 
     # If OOM is hit, we expect code 507 to be present in the response string
-    lines = response.split("\n")
     output = ""
-    for line in lines:
-        if "code" in line:
-            line = line.strip()
-            output = line
+    for response in responses:
+        if '"code": 507,' in response:
+            output = '"code": 507,'
             break
     assert output == '"code": 507,', "OOM Error expected"
diff --git a/ts_scripts/api_utils.py b/ts_scripts/api_utils.py
index 02e1fa4bc30..b79b0338451 100755
--- a/ts_scripts/api_utils.py
+++ b/ts_scripts/api_utils.py
@@ -2,6 +2,7 @@
 import os
 import shutil
 import sys
+import subprocess
 
 REPO_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
 sys.path.append(REPO_ROOT)
@@ -127,9 +128,21 @@ def trigger_management_tests():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_MANAGEMENT} -d {POSTMAN_MANAGEMENT_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_MANAGEMENT_DIR}/{REPORT_FILE} --verbose"
-    )
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_MANAGEMENT,
+        "-d", POSTMAN_MANAGEMENT_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_MANAGEMENT_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_MANAGEMENT_DIR)
     cleanup_model_store()
@@ -150,9 +163,21 @@ def trigger_inference_tests():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_INFERENCE} -d {POSTMAN_INFERENCE_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_INFERENCE_DIR}/{REPORT_FILE} --verbose"
-    )
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_INFERENCE,
+        "-d", POSTMAN_INFERENCE_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_INFERENCE_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_INFERENCE_DIR)
     cleanup_model_store()
@@ -173,9 +198,22 @@ def trigger_workflow_tests():
         workflow_store=MODEL_STORE_DIR,
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_WORKFLOW} -d {POSTMAN_WORKFLOW_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_WORKFLOW_MANAGEMENT_DIR}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_WORKFLOW,
+        "-d", POSTMAN_WORKFLOW_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_WORKFLOW_MANAGEMENT_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_WORKFLOW_MANAGEMENT_DIR)
     cleanup_model_store()
@@ -195,9 +233,21 @@ def trigger_workflow_inference_tests():
         workflow_store=MODEL_STORE_DIR,
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_WORKFLOW_INFERENCE} -d {POSTMAN_WORKFLOW_INFERENCE_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_WORKFLOW_INFERENCE_DIR}/{REPORT_FILE} --verbose"
-    )
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_WORKFLOW_INFERENCE,
+        "-d", POSTMAN_WORKFLOW_INFERENCE_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_WORKFLOW_INFERENCE_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_WORKFLOW_INFERENCE_DIR)
     cleanup_model_store()
@@ -218,9 +268,22 @@ def trigger_explanation_tests():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_EXPLANATION} -d {POSTMAN_EXPLANATION_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_INFERENCE_DIR}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_EXPLANATION,
+        "-d", POSTMAN_EXPLANATION_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_EXPLANATION_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_EXPLANATION_DIR)
     cleanup_model_store()
@@ -245,9 +308,23 @@ def trigger_incr_timeout_inference_tests():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_INFERENCE} -d {POSTMAN_INCRSD_TIMEOUT_INFERENCE_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_INCRSD_TIMEOUT_INFERENCE_DIR}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_INFERENCE,
+        "-d", POSTMAN_INCRSD_TIMEOUT_INFERENCE_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_INCRSD_TIMEOUT_INFERENCE_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_INCRSD_TIMEOUT_INFERENCE_DIR)
     cleanup_model_store()
@@ -264,9 +341,23 @@ def trigger_https_tests():
         config_file=TS_CONFIG_FILE_HTTPS,
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run --insecure -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_HTTPS} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_HTTPS_DIR}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "--insecure",  # Option to allow insecure HTTPS requests
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_HTTPS,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_HTTPS_DIR}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_HTTPS_DIR)
     cleanup_model_store()
@@ -289,9 +380,23 @@ def trigger_management_tests_kf():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_MANAGEMENT} -d {POSTMAN_MANAGEMENT_DATA_FILE} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_MANAGEMENT_DIR_KF}/{REPORT_FILE} --verbose"
-    )
+    
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_MANAGEMENT,
+        "-d", POSTMAN_MANAGEMENT_DATA_FILE,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_MANAGEMENT_DIR_KF}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+    
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_MANAGEMENT_DIR_KF)
     cleanup_model_store()
@@ -315,9 +420,23 @@ def trigger_inference_tests_kf():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_INFERENCE_KF} -d {POSTMAN_INFERENCE_DATA_FILE_KF} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_INFERENCE_DIR_KF}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_INFERENCE_KF,
+        "-d", POSTMAN_INFERENCE_DATA_FILE_KF,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_INFERENCE_DIR_KF}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_INFERENCE_DIR_KF)
     cleanup_model_store()
@@ -333,9 +452,23 @@ def trigger_https_tests_kf():
         config_file=TS_CONFIG_FILE_HTTPS_KF,
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run --insecure -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_HTTPS_KF} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_HTTPS_DIR_KF}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "--insecure",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_HTTPS_KF,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_HTTPS_DIR_KF}/{REPORT_FILE}",
+        "--verbose"
+    ]
+    
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_HTTPS_DIR_KF)
     cleanup_model_store()
@@ -358,9 +491,23 @@ def trigger_inference_tests_kfv2():
         config_file="config.properties",
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_INFERENCE_KFV2} -d {POSTMAN_INFERENCE_DATA_FILE_KFV2} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_INFERENCE_DIR_KFV2}/{REPORT_FILE} --verbose"
-    )
+
+    command = [
+        "newman", "run",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_INFERENCE_KFV2,
+        "-d", POSTMAN_INFERENCE_DATA_FILE_KFV2,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_INFERENCE_DIR_KFV2}/{REPORT_FILE}",
+        "--verbose"
+    ]
+
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_INFERENCE_DIR_KFV2)
     cleanup_model_store()
@@ -376,9 +523,22 @@ def trigger_https_tests_kfv2():
         config_file=TS_CONFIG_FILE_HTTPS_KFV2,
         log_file=TS_CONSOLE_LOG_FILE,
     )
-    EXIT_CODE = os.system(
-        f"newman run --insecure -e {POSTMAN_ENV_FILE} {POSTMAN_COLLECTION_HTTPS_KFV2} -r cli,htmlextra --reporter-htmlextra-export {ARTIFACTS_HTTPS_DIR_KFV2}/{REPORT_FILE} --verbose"
-    )
+    command = [
+        "newman", "run",
+        "--insecure",
+        "-e", POSTMAN_ENV_FILE,
+        POSTMAN_COLLECTION_HTTPS_KFV2,
+        "-r", "cli,htmlextra",
+        "--reporter-htmlextra-export", f"{ARTIFACTS_HTTPS_DIR_KFV2}/{REPORT_FILE}",
+        "--verbose"
+    ]
+
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, check=True)
+        EXIT_CODE = result.returncode
+    except subprocess.CalledProcessError as e:
+        EXIT_CODE = e.returncode
+
     ts.stop_torchserve()
     move_logs(TS_CONSOLE_LOG_FILE, ARTIFACTS_HTTPS_DIR_KFV2)
     cleanup_model_store()
diff --git a/ts_scripts/backend_utils.py b/ts_scripts/backend_utils.py
index e5d0ea6c226..2619297b5b1 100755
--- a/ts_scripts/backend_utils.py
+++ b/ts_scripts/backend_utils.py
@@ -1,4 +1,5 @@
 import os
+import subprocess
 import sys
 
 
@@ -14,9 +15,16 @@ def test_torchserve():
     coverage_dir = os.path.join("ts")
     report_output_dir = os.path.join(test_dir, "coverage.xml")
 
-    ts_test_cmd = f"python -m pytest --cov-report xml:{report_output_dir} --cov={coverage_dir} {test_dir} {handler_test_dir}"
+    ts_test_cmd = [
+        "python", "-m", "pytest",
+        "--cov-report", f"xml:{report_output_dir}",
+        "--cov", coverage_dir,
+        test_dir,
+        handler_test_dir
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {ts_test_cmd}")
-    ts_test_error_code = os.system(ts_test_cmd)
+    try:
+        subprocess.run(ts_test_cmd, capture_output=True, text=True, check=True)
+    except subprocess.CalledProcessError as e:
+        sys.exit(e.returncode)
 
-    if ts_test_error_code != 0:
-        sys.exit("## TorchServe Pytests Failed !")
diff --git a/ts_scripts/frontend_utils.py b/ts_scripts/frontend_utils.py
index a8eddc6ca16..fc430b47259 100755
--- a/ts_scripts/frontend_utils.py
+++ b/ts_scripts/frontend_utils.py
@@ -1,13 +1,14 @@
 import os
 import sys
-
+import subprocess
 
 def test_frontend():
     print("## Started frontend build and tests")
     frontend_gradlew_path = os.path.join("frontend", "gradlew")
-    frontend_gradlew_cmd = f"{frontend_gradlew_path} -p frontend clean build"
+    frontend_gradlew_cmd = [frontend_gradlew_path, "-p", "frontend", "clean", "build"]
     print(f"## In directory: {os.getcwd()} | Executing command: {frontend_gradlew_cmd}")
-    frontend_gradlew_exit_code = os.system(frontend_gradlew_cmd)
 
-    if frontend_gradlew_exit_code != 0:
+    try:
+        subprocess.run(frontend_gradlew_cmd, capture_output=True, text=True, check=True)
+    except subprocess.CalledProcessError:
         sys.exit("## Frontend Gradle Tests Failed !")
diff --git a/ts_scripts/install_dependencies.py b/ts_scripts/install_dependencies.py
index 20bd76599aa..83dcd06f287 100644
--- a/ts_scripts/install_dependencies.py
+++ b/ts_scripts/install_dependencies.py
@@ -1,6 +1,8 @@
 import argparse
 import os
 import platform
+import shlex
+import subprocess
 import sys
 
 from print_env_info import run_and_parse_first_match
@@ -88,6 +90,15 @@ def __init__(self):
         self.torch_stable_url = "https://download.pytorch.org/whl/torch_stable.html"
         self.sudo_cmd = "sudo "
 
+    def check_command(self, command):
+        """Check if a command is available on the system."""
+        try:
+            command = shlex.split(command)
+            subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+    
     def install_java(self):
         pass
 
@@ -107,63 +118,103 @@ def install_torch_packages(self, cuda_version):
                 )
                 sys.exit(1)
             else:
-                os.system(
-                    f"{sys.executable} -m pip install -U -r requirements/torch_{cuda_version}_{platform.system().lower()}.txt"
-                )
+                torch_cuda_requirements_file = f"requirements/torch_{cuda_version}_{platform.system().lower()}.txt"
+                try:
+                    subprocess.run(
+                        [sys.executable, "-m", "pip", "install", "-U", "-r", torch_cuda_requirements_file],
+                        capture_output=True, text=True, check=True
+                    )
+                except subprocess.CalledProcessError as e:
+                    sys.exit(e.returncode)
         elif args.neuronx:
-            torch_neuronx_requirements_file = os.path.join(
-                "requirements", "torch_neuronx_linux.txt"
-            )
-            os.system(
-                f"{sys.executable} -m pip install -U -r {torch_neuronx_requirements_file}"
-            )
+            torch_neuronx_requirements_file = "requirements/torch_neuronx_linux.txt"
+            try:
+                subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "-U", "-r", torch_neuronx_requirements_file],
+                    capture_output=True, text=True, check=True
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
         else:
             if platform.machine() == "aarch64":
-                os.system(
-                    f"{sys.executable} -m pip install -U -r requirements/torch_{platform.system().lower()}_{platform.machine()}.txt"
-                )
+                requirements_file = f"requirements/torch_{platform.system().lower()}_{platform.machine()}.txt"
             else:
-                os.system(
-                    f"{sys.executable} -m pip install -U -r requirements/torch_{platform.system().lower()}.txt"
+                requirements_file = f"requirements/torch_{platform.system().lower()}.txt"
+            try:
+                subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "-U", "-r", requirements_file],
+                    capture_output=True, text=True, check=True
                 )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
 
     def install_python_packages(self, cuda_version, requirements_file_path, nightly):
         check = "where" if platform.system() == "Windows" else "which"
-        if os.system(f"{check} conda") == 0:
+        if subprocess.run([check, "conda"], capture_output=True).returncode == 0:
             # conda install command should run before the pip install commands
             # as it may reinstall the packages with different versions
-            os.system("conda install -y conda-build")
+            print("Conda found. Installing conda-build...")
+        try:
+            result = subprocess.run(
+                ["conda", "install", "-y", "conda-build"],
+                capture_output=True, text=True, check=True
+            )
+            print(result.stdout)
+        except subprocess.CalledProcessError as e:
+            print(f"Error installing conda-build: {e.stderr}")
+            sys.exit(e.returncode)
 
         # Install PyTorch packages
         if nightly:
             pt_nightly = "cpu" if not cuda_version else cuda_version
-            os.system(
-                f"pip3 install numpy --pre torch torchvision torchaudio torchtext --index-url https://download.pytorch.org/whl/nightly/{pt_nightly}"
-            )
+            try:
+                subprocess.run(
+                    [
+                        "pip3", "install", "numpy", "--pre", "torch", "torchvision", "torchaudio", "torchtext",
+                        f"--index-url=https://download.pytorch.org/whl/nightly/{pt_nightly}"
+                    ],
+                    capture_output=True, text=True, check=True
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
         elif args.skip_torch_install:
             print("Skipping Torch installation")
         else:
             self.install_torch_packages(cuda_version)
 
         # developer.txt also installs packages from common.txt
-        os.system(f"{sys.executable} -m pip install -U -r {requirements_file_path}")
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "-U", "-r", requirements_file_path],
+                capture_output=True, text=True, check=True
+            )
+        except subprocess.CalledProcessError as e:
+            sys.exit(e.returncode)
 
         # Install dependencies for GPU
         if not isinstance(cuda_version, type(None)):
             gpu_requirements_file = os.path.join("requirements", "common_gpu.txt")
-            os.system(f"{sys.executable} -m pip install -U -r {gpu_requirements_file}")
+            try:
+                subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "-U", "-r", gpu_requirements_file],
+                    capture_output=True, text=True, check=True
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
 
         # Install dependencies for Inferentia2
         if args.neuronx:
             neuronx_requirements_file = os.path.join("requirements", "neuronx.txt")
-            os.system(
-                f"{sys.executable} -m pip install -U -r {neuronx_requirements_file}"
-            )
+            try:
+                subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "-U", "-r", neuronx_requirements_file],
+                    capture_output=True, text=True, check=True
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
 
     def install_node_packages(self):
-        os.system(
-            f"{self.sudo_cmd}npm install -g newman@5.3.2 newman-reporter-htmlextra markdown-link-check"
-        )
+        subprocess.run([{self.sudo_cmd}, "npm", "install", "-g", "newman@5.3.2", "newman-reporter-htmlextra", "markdown-link-check"], check=True)
 
     def install_jmeter(self):
         pass
@@ -190,55 +241,46 @@ def __init__(self):
         self.sudo_cmd = "" if os.geteuid() == 0 else self.sudo_cmd
 
         if args.force:
-            os.system(f"{self.sudo_cmd}apt-get update")
+            subprocess.run([self.sudo_cmd, "apt-get", "update"], check=True)
 
     def install_java(self):
-        if os.system("javac --version") != 0 or args.force:
-            os.system(f"{self.sudo_cmd}apt-get install -y openjdk-17-jdk")
+        if self.check_command("javac --version") or args.force:
+            subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "openjdk-17-jdk"], check=True)
 
     def install_nodejs(self):
-        if os.system("node -v") != 0 or args.force:
-            os.system(
-                f"{self.sudo_cmd}curl -sL https://deb.nodesource.com/setup_18.x | {self.sudo_cmd}bash -"
-            )
-            os.system(f"{self.sudo_cmd}apt-get install -y nodejs")
+        if self.check_command("node -v") or args.force:
+            subprocess.run([self.sudo_cmd, "curl", "-sL", "https://deb.nodesource.com/setup_18.x", "|", "bash", "-"], check=True)
+            subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "nodejs"], check=True)
 
     def install_wget(self):
-        if os.system("wget --version") != 0 or args.force:
-            os.system(f"{self.sudo_cmd}apt-get install -y wget")
+        if self.check_command("wget --version") or args.force:
+            subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "wget"], check=True)
 
     def install_numactl(self):
-        if os.system("numactl --show") != 0 or args.force:
-            os.system(f"{self.sudo_cmd}apt-get install -y numactl")
+        if self.check_command("numactl --show") or args.force:
+            subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "numactl"], check=True)
 
     def install_cpp_dependencies(self):
-        os.system(
-            f"{self.sudo_cmd}apt-get install -y {' '.join(CPP_LINUX_DEPENDENCIES)}"
-        )
+        subprocess.run([self.sudo_cmd, ["apt-get", "install", "-y"] + list(CPP_LINUX_DEPENDENCIES)], check=True)
 
     def install_neuronx_driver(self):
         # Configure Linux for Neuron repository updates
-        os.system(
-            ". /etc/os-release\n"
-            + f"{self.sudo_cmd}tee /etc/apt/sources.list.d/neuron.list > /dev/null <<EOF\n"
-            + "deb https://apt.repos.neuron.amazonaws.com ${VERSION_CODENAME} main\n"
-            + "EOF\n"
-            + "wget -qO - https://apt.repos.neuron.amazonaws.com/GPG-PUB-KEY-AMAZON-AWS-NEURON.PUB | sudo apt-key add -"
-        )
+        subprocess.run([self.sudo_cmd, "tee", "/etc/apt/sources.list.d/neuron.list"], input=f"deb https://apt.repos.neuron.amazonaws.com {os.environ['VERSION_CODENAME']} main\n", text=True, check=True)
+        subprocess.run(["wget", "-qO", "-", "https://apt.repos.neuron.amazonaws.com/GPG-PUB-KEY-AMAZON-AWS-NEURON.PUB"], check=True, stdout=subprocess.PIPE)
+        subprocess.run([self.sudo_cmd, "apt-key", "add", "-"], input=subprocess.PIPE)
 
         # Update OS packages
-        os.system(f"{self.sudo_cmd}apt-get update -y")
+        subprocess.run([self.sudo_cmd, "apt-get", "update", "-y"], check=True)
 
         # Install OS headers
-        os.system(f"{self.sudo_cmd}apt-get install -y linux-headers-$(uname -r)")
+        subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", f"linux-headers-{os.uname().release}"], check=True)
 
         # install Neuron Driver
-        os.system(f"{self.sudo_cmd}apt-get install -y aws-neuronx-dkms")
+        subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "aws-neuronx-dkms"], check=True)
 
         # Install Neuron Runtime
-        os.system(f"{self.sudo_cmd}apt-get install -y aws-neuronx-collectives")
-        os.system(f"{self.sudo_cmd}apt-get install -y aws-neuronx-runtime-lib")
-
+        subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "aws-neuronx-collectives"], check=True)
+        subprocess.run([self.sudo_cmd, "apt-get", "install", "-y", "aws-neuronx-runtime-lib"], check=True)
 
 class Windows(Common):
     def __init__(self):
@@ -266,41 +308,41 @@ def __init__(self):
         super().__init__()
 
     def install_java(self):
-        if os.system("javac -version") != 0 or args.force:
+        if self.check_command("javac -version") or args.force:
             out = get_brew_version()
             if out == "N/A":
                 sys.exit("**Error: Homebrew not installed...")
-            os.system("brew install openjdk@17")
+            subprocess.run(["brew", "install", "openjdk@17"], check=True)
 
     def install_nodejs(self):
-        os.system("brew unlink node")
-        os.system("brew install node@18")
-        os.system("brew link --overwrite node@18")
+        subprocess.run(["brew", "unlink", "node"], check=True)
+        subprocess.run(["brew", "install", "node@18"], check=True)
+        subprocess.run(["brew", "link", "--overwrite", "node@18"], check=True)
 
     def install_node_packages(self):
-        os.system(f"{self.sudo_cmd} ./ts_scripts/mac_npm_deps")
+        subprocess.run([self.sudo_cmd, "./ts_scripts/mac_npm_deps"], check=True)
 
     def install_wget(self):
-        if os.system("wget --version") != 0 or args.force:
-            os.system("brew install wget")
+        if self.check_command("wget --version") or args.force:
+            subprocess.run(["brew", "install", "wget"], check=True)
 
     def install_numactl(self):
-        if os.system("numactl --show") != 0 or args.force:
-            os.system("brew install numactl")
+        if self.check_command("numactl --show") or args.force:
+            subprocess.run(["brew", "install", "numactl"], check=True)
 
     def install_cpp_dependencies(self):
-        if os.system("clang-tidy --version") != 0 or args.force:
-            os.system(f"brew install -f {' '.join(CPP_DARWIN_DEPENDENCIES)}")
-            os.system(f"brew link {' '.join(CPP_DARWIN_DEPENDENCIES_LINK)}")
-            os.system(
-                f'{self.sudo_cmd} ln -s "$(brew --prefix llvm)/bin/clang-format" "/usr/local/bin/clang-format"'
-            )
-            os.system(
-                f'{self.sudo_cmd} ln -s "$(brew --prefix llvm)/bin/clang-tidy" "/usr/local/bin/clang-tidy"'
-            )
-            os.system(
-                f'{self.sudo_cmd} ln -s "$(brew --prefix llvm)/bin/clang-apply-replacements" "/usr/local/bin/clang-apply-replacements"'
-            )
+        if self.check_command("clang-tidy --version") or args.force:
+            subprocess.run(["brew", "install", "-f"] + list(CPP_DARWIN_DEPENDENCIES), check=True)
+            subprocess.run(["brew", "link"] + list(CPP_DARWIN_DEPENDENCIES_LINK), check=True)
+            subprocess.run([
+                self.sudo_cmd, "ln", "-s", f"{self._get_brew_prefix('llvm')}/bin/clang-format", "/usr/local/bin/clang-format"
+            ], check=True)
+            subprocess.run([
+                self.sudo_cmd, "ln", "-s", f"{self._get_brew_prefix('llvm')}/bin/clang-tidy", "/usr/local/bin/clang-tidy"
+            ], check=True)
+            subprocess.run([
+                self.sudo_cmd, "ln", "-s", f"{self._get_brew_prefix('llvm')}/bin/clang-apply-replacements", "/usr/local/bin/clang-apply-replacements"
+            ], check=True)
 
     def install_neuronx_driver(self):
         pass
diff --git a/ts_scripts/install_from_src.py b/ts_scripts/install_from_src.py
index 9c555f9c3de..8b5c1182b7c 100644
--- a/ts_scripts/install_from_src.py
+++ b/ts_scripts/install_from_src.py
@@ -1,6 +1,7 @@
 import argparse
 import os
 import sys
+import subprocess
 
 # To help discover local modules
 REPO_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
@@ -13,12 +14,17 @@
 def install_from_src(dev=False):
     for binary in [".", "model-archiver/.", "workflow-archiver/."]:
         cmd = (
-            f"pip install --force-reinstall -e {binary}"
+            ["pip", "install", "--force-reinstall", "-e", binary]
             if dev
-            else f"pip install --force-reinstall {binary}"
+            else ["pip", "install", "--force-reinstall", binary]
         )
         print(f"## In directory {os.getcwd()} | Executing command {cmd}")
-        os.system(cmd)
+        subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
 
 
 if __name__ == "__main__":
diff --git a/ts_scripts/modelarchiver_utils.py b/ts_scripts/modelarchiver_utils.py
index d1cf3903a1f..0f1a980f602 100644
--- a/ts_scripts/modelarchiver_utils.py
+++ b/ts_scripts/modelarchiver_utils.py
@@ -1,5 +1,6 @@
 import os
 import sys
+import subprocess
 
 REPO_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
 sys.path.append(REPO_ROOT)
@@ -14,22 +15,43 @@ def test_modelarchiver():
     coverage_dir = os.path.join(".")
     report_output_dir = os.path.join(ut_dir, "coverage.xml")
 
-    py_units_cmd = f"python -m pytest --cov-report xml:{report_output_dir} --cov={coverage_dir} {ut_dir}"
+    py_units_cmd = [
+        "python", "-m", "pytest", 
+        f"--cov-report=xml:{report_output_dir}", 
+        f"--cov={coverage_dir}", 
+        ut_dir
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {py_units_cmd}")
-    py_units_exit_code = os.system(py_units_cmd)
+    try:
+        subprocess.run(
+            py_units_cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        sys.exit("## Model archiver Unit Pytests Failed !")
 
     # Execute integration tests
     print("## Started model archiver pytests - integration tests")
     it_dir = os.path.join("model_archiver", "tests", "integ_tests")
     report_output_dir = os.path.join(it_dir, "coverage.xml")
 
-    py_integ_cmd = f"python -m pytest --cov-report xml:{report_output_dir} --cov={coverage_dir} {it_dir}"
+    py_integ_cmd = [
+        "python", "-m", "pytest", 
+        f"--cov-report=xml:{report_output_dir}", 
+        f"--cov={coverage_dir}", 
+        it_dir
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {py_integ_cmd}")
-    py_integ_exit_code = os.system(py_integ_cmd)
-
-    if py_units_exit_code != 0:
-        sys.exit("## Model archiver Unit Pytests Failed !")
-    if py_integ_exit_code != 0:
+    try:
+        subprocess.run(
+            py_integ_cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
         sys.exit("## Model archiver Integration Pytests Failed !")
 
     os.chdir(REPO_ROOT)
diff --git a/ts_scripts/regression_utils.py b/ts_scripts/regression_utils.py
index 419b1d3e06a..35b56234278 100644
--- a/ts_scripts/regression_utils.py
+++ b/ts_scripts/regression_utils.py
@@ -2,6 +2,7 @@
 import sys
 import tempfile
 import urllib.request
+import subprocess
 
 from ts_scripts.shell_utils import rm_file
 
@@ -35,39 +36,53 @@ def generate_densenet_test_model_archive():
     urllib.request.urlretrieve(serialized_model_file_url, serialized_model_file_name)
 
     # create mar command
-    cmd = f"torch-model-archiver \
-                --model-name {model_name} \
-                --version {version} \
-                --model-file {model_file} \
-                --serialized-file {serialized_file_path} \
-                --extra-files {extra_files} \
-                --handler {handler} \
-                --force"
+    cmd = [
+        "torch-model-archiver",
+        "--model-name", model_name,
+        "--version", version,
+        "--model-file", model_file,
+        "--serialized-file", serialized_file_path,
+        "--extra-files", extra_files,
+        "--handler", handler,
+        "--force"
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {cmd}")
-    sys_exit_code = os.system(cmd)
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    
     os.remove(serialized_file_path)
     os.chdir(REPO_ROOT)
-    return sys_exit_code
+    return result.returncode
 
 
 def run_pytest():
     print("## Started regression pytests")
-    os.chdir(os.path.join(REPO_ROOT, "test", "pytest"))
-    cmd = (
-        "python -m grpc_tools.protoc -I ../../third_party/google/rpc --proto_path=../../frontend/server/src/main/resources/proto/"
-        " --python_out=. --grpc_python_out=. ../../frontend/server/src/main/resources/proto/inference.proto"
-        " ../../frontend/server/src/main/resources/proto/management.proto"
-    )
-    status = os.system(cmd)
-    if status != 0:
+    proto_dir = os.path.join(REPO_ROOT, "frontend", "server", "src", "main", "resources", "proto")
+    third_party_dir = os.path.join(REPO_ROOT, "third_party", "google", "rpc")
+    proto_files = [
+        "inference.proto",
+        "management.proto"
+    ]
+    cmd = [
+        "python", "-m", "grpc_tools.protoc",
+        "-I", third_party_dir,
+        "--proto_path", proto_dir
+    ]
+    cmd += ["--python_out=.", "--grpc_python_out=."] + [os.path.join(proto_dir, proto_file) for proto_file in proto_files]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
         print("Could not generate gRPC client stubs")
         sys.exit(1)
 
-    cmd = "python -m pytest -v ./ --ignore=sanity"
+    pytest_cmd = ["python", "-m", "pytest", "-v", "./", "--ignore=sanity"]
     print(f"## In directory: {os.getcwd()} | Executing command: {cmd}")
-    status = os.system(cmd)
+    result = subprocess.run(pytest_cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f"Pytest failed with return code {result.returncode}")
+
     rm_file("*_pb2*.py", True)
-    return status
+    return result.returncode
 
 
 def test_regression():
diff --git a/ts_scripts/sanity_utils.py b/ts_scripts/sanity_utils.py
index f6b51262131..2658ce63de8 100755
--- a/ts_scripts/sanity_utils.py
+++ b/ts_scripts/sanity_utils.py
@@ -118,10 +118,16 @@ def run_grpc_test(model: dict):
     print("pass mg.mar_set=", mg.mar_set)
     mar_set_list_str = [str(s) for s in mg.mar_set]
     mar_set_str = ",".join(mar_set_list_str)
-    register_model_grpc_cmd = f"python ts_scripts/torchserve_grpc_client.py register {model_name} {mar_set_str}"
-    status = os.system(register_model_grpc_cmd)
-
-    if status != 0:
+    register_model_grpc_cmd = [
+        "python",
+        "ts_scripts/torchserve_grpc_client.py",
+        "register",
+        model_name,
+        mar_set_str
+    ]
+    result = subprocess.run(register_model_grpc_cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
         print("## Failed to register model with torchserve")
         sys.exit(1)
     else:
@@ -147,12 +153,15 @@ def run_grpc_test(model: dict):
         else:
             print(f"## Successfully ran inference on {model_name} model.")
 
-    unregister_model_grpc_cmd = (
-        f"python ts_scripts/torchserve_grpc_client.py unregister {model_name}"
-    )
-    status = os.system(unregister_model_grpc_cmd)
+    unregister_model_grpc_cmd = [
+        "python",
+        "ts_scripts/torchserve_grpc_client.py",
+        "unregister",
+        model_name
+    ]
+    result = subprocess.run(unregister_model_grpc_cmd, capture_output=True, text=True)
 
-    if status != 0:
+    if result.returncode != 0:
         print(f"## Failed to unregister {model_name}")
         sys.exit(1)
     else:
@@ -209,14 +218,18 @@ def test_sanity():
     coverage_dir = os.path.join("ts")
     report_output_dir = os.path.join(test_dir, "coverage.xml")
 
-    ts_test_cmd = f"python -m pytest --cov-report xml:{report_output_dir} --cov={coverage_dir} {test_dir}"
+    ts_test_cmd = [
+        "python", "-m", "pytest",
+        "--cov-report", f"xml:{report_output_dir}",
+        "--cov", coverage_dir,
+        test_dir
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {ts_test_cmd}")
-    ts_test_error_code = os.system(ts_test_cmd)
+    result = subprocess.run(ts_test_cmd, capture_output=True, text=True)
 
-    if ts_test_error_code != 0:
+    if result.returncode != 0:
         sys.exit("## TorchServe sanity test failed !")
 
-
 def test_workflow_sanity():
     current_path = os.getcwd()
     ts_log_file = os.path.join("logs", "ts_console.log")
diff --git a/ts_scripts/tsutils.py b/ts_scripts/tsutils.py
index ef7b4078197..16267bbcaff 100644
--- a/ts_scripts/tsutils.py
+++ b/ts_scripts/tsutils.py
@@ -3,8 +3,7 @@
 import sys
 import threading
 from pathlib import Path
-from subprocess import PIPE, STDOUT, Popen
-
+import subprocess
 import requests
 
 from ts_scripts import marsgen as mg
@@ -72,7 +71,7 @@ def start_torchserve(
     if log_file:
         print(f"## Console logs redirected to file: {log_file}")
     print(f"## In directory: {os.getcwd()} | Executing command: {' '.join(cmd)}")
-    p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+    p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     if log_file:
         Path(log_file).parent.absolute().mkdir(parents=True, exist_ok=True)
         with open(log_file, "a") as f:
@@ -101,7 +100,7 @@ def stop_torchserve():
     cmd = [f"{torchserve_command[platform.system()]}"]
     cmd.append("--stop")
     print(f"## In directory: {os.getcwd()} | Executing command: {cmd}")
-    p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+    p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
     status = p.wait()
     if status == 0:
@@ -150,13 +149,17 @@ def unregister_model(model_name, protocol="http", host="localhost", port="8081")
 
 def generate_grpc_client_stubs():
     print("## Started generating gRPC clinet stubs")
-    cmd = (
-        "python -m grpc_tools.protoc -I third_party/google/rpc --proto_path=frontend/server/src/main/resources/proto/ --python_out=ts_scripts "
-        "--grpc_python_out=ts_scripts frontend/server/src/main/resources/proto/inference.proto "
+    cmd = [
+        "python", "-m", "grpc_tools.protoc",
+        "-I", "third_party/google/rpc",
+        "--proto_path", "frontend/server/src/main/resources/proto/",
+        "--python_out=ts_scripts",
+        "--grpc_python_out=ts_scripts",
+        "frontend/server/src/main/resources/proto/inference.proto",
         "frontend/server/src/main/resources/proto/management.proto"
-    )
-    status = os.system(cmd)
-    if status != 0:
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
         print("Could not generate gRPC client stubs")
         sys.exit(1)
 
diff --git a/ts_scripts/utils.py b/ts_scripts/utils.py
index 0566edcb1da..60b43f215df 100644
--- a/ts_scripts/utils.py
+++ b/ts_scripts/utils.py
@@ -15,15 +15,29 @@
 
 
 def is_gpu_instance():
-    return True if os.system(nvidia_smi_cmd[platform.system()]) == 0 else False
+    cmd = nvidia_smi_cmd.get(platform.system())
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode == 0:
+        return True
+    else:
+        return False
 
 
 def is_conda_build_env():
-    return True if os.system("conda-build") == 0 else False
+    result = subprocess.run(["conda-build"], capture_output=True, text=True)
+    if result.returncode == 0:
+        return True
+    else:
+        return False
 
 
 def is_conda_env():
-    return True if os.system("conda") == 0 else False
+    result = subprocess.run(["conda"], capture_output=True, text=True)
+    if result.returncode == 0:
+        return True
+    else:
+        return False
 
 
 def check_python_version():
@@ -56,3 +70,11 @@ def try_and_handle(cmd, dry_run=False):
             subprocess.run(cmd, check=True)
         except subprocess.CalledProcessError as e:
             raise (e)
+
+def find_conda_binary():
+    try:
+        subprocess.run(["conda", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        conda_path = subprocess.check_output(["which", "conda"], text=True).strip()
+    except subprocess.CalledProcessError:
+        conda_path = os.path.expanduser("$HOME/miniconda/condabin/conda")
+    return conda_path
diff --git a/ts_scripts/workflow_archiver_utils.py b/ts_scripts/workflow_archiver_utils.py
index 5d34c78452f..e4405a2a602 100644
--- a/ts_scripts/workflow_archiver_utils.py
+++ b/ts_scripts/workflow_archiver_utils.py
@@ -1,5 +1,6 @@
 import os
 import sys
+import subprocess
 
 REPO_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")
 sys.path.append(REPO_ROOT)
@@ -13,17 +14,29 @@ def test_workflow_archiver():
     ut_dir = os.path.join("workflow_archiver", "tests", "unit_tests")
     coverage_dir = os.path.join(".")
     report_output_dir = os.path.join(ut_dir, "coverage.xml")
-    py_units_cmd = f"python -m pytest --cov-report xml:{report_output_dir} --cov={coverage_dir} {ut_dir}"
+    py_units_cmd = [
+        "python", "-m", "pytest",
+        "--cov-report", f"xml:{report_output_dir}",
+        "--cov", coverage_dir,
+        ut_dir
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {py_units_cmd}")
-    py_units_exit_code = os.system(py_units_cmd)
+    result = subprocess.run(py_units_cmd, capture_output=True, text=True)
+    py_units_exit_code = result.returncode
 
     # Execute integration tests
     print("## Started workflow archiver pytests - integration tests")
     it_dir = os.path.join("workflow_archiver", "tests", "integ_tests")
     report_output_dir = os.path.join(it_dir, "coverage.xml")
-    py_integ_cmd = f"python -m pytest --cov-report xml:{report_output_dir} --cov={coverage_dir} {it_dir}"
+    py_integ_cmd = [
+        "python", "-m", "pytest",
+        "--cov-report", f"xml:{report_output_dir}",
+        "--cov", coverage_dir,
+        it_dir
+    ]
     print(f"## In directory: {os.getcwd()} | Executing command: {py_integ_cmd}")
-    py_integ_exit_code = os.system(py_integ_cmd)
+    result = subprocess.run(py_integ_cmd, capture_output=True, text=True)
+    py_integ_exit_code = result.returncode
 
     if py_units_exit_code != 0:
         sys.exit("## Workflow archiver Unit Pytests Failed !")