diff --git a/docs/wes_platform.md b/docs/wes_platform.md
new file mode 100644
index 00000000..c3641834
--- /dev/null
+++ b/docs/wes_platform.md
@@ -0,0 +1,126 @@
+# GA4GH WES Platform Implementation
+
+This document describes the GA4GH Workflow Execution Service (WES) platform implementation for the PAML library.
+
+## Overview
+
+The GA4GH WES API provides a standard way to submit and manage workflows across different workflow execution systems. 
+This implementation allows you to use the PAML library to submit workflows to any WES-compatible service.
+
+The WES platform implementation (`GA4GHWESPlatform`) inherits from the `Platform` abstract base class and implements all the required methods to interact with a WES API endpoint.
+
+## Features
+
+- Connect to any WES API endpoint
+- Submit CWL workflows
+- Monitor workflow execution status
+- Retrieve workflow outputs
+
+## Limitations
+
+Since the WES API is focused on workflow execution and doesn't include concepts like projects, folders, or file management, some features of the Platform API are not fully supported:
+
+- File operations (upload, download, copy) are limited
+- Project management is simulated using virtual projects
+- User management is not supported
+
+## Usage
+
+### Initialization and Connection
+
+```python
+from src.cwl_platform import PlatformFactory
+
+# Initialize the platform factory
+factory = PlatformFactory()
+
+# Get the WES platform
+platform = factory.get_platform('GA4GHWESPlatform')
+
+# Connect to the WES API
+platform.connect(
+    api_endpoint="https://wes.example.com/ga4gh/wes/v1",
+    auth_token="your_auth_token"  # Optional
+)
+```
+
+### Submitting a Workflow
+
+```python
+
+# Create a virtual project (not used by WES but required by the API)
+project = {
+    project_name = 'GA4GH WES Example Project'
+}
+#project = platform.create_project('wes-example', 'WES Example Project')
+
+# Define workflow parameters
+workflow_parameters = {
+    "input_file": {
+        "class": "File",
+        "path": "platform-specific id"
+    },
+    "output_filename": "output.txt"
+}
+
+# Submit the workflow
+task = platform.submit_task(
+    name="My Workflow",
+    project=project,
+    workflow="platform://<platform-specific workflow id",  # URL or local file path
+    parameters=workflow_parameters
+    execution_settings={
+        'workflow_engine': 'Arvados'
+    }
+)
+
+# Get the run ID
+run_id = task.run_id
+```
+
+### Monitoring Workflow Execution
+
+```python
+# Check the workflow state
+state = platform.get_task_state(task)
+print(f"Workflow state: {state}")
+
+# Refresh the state from the server
+state = platform.get_task_state(task, refresh=True)
+print(f"Updated workflow state: {state}")
+
+# Monitor until completion
+import time
+while True:
+    state = platform.get_task_state(task, refresh=True)
+    print(f"Workflow state: {state}")
+    
+    if state in ['Complete', 'Failed', 'Cancelled']:
+        break
+        
+    time.sleep(10)  # Check every 10 seconds
+```
+
+### Retrieving Workflow Outputs
+
+```python
+# Get all outputs
+outputs = platform.get_task_outputs(task)
+print(f"Outputs: {outputs}")
+
+# Get a specific output
+output_file = platform.get_task_output(task, "output_file")
+print(f"Output file: {output_file}")
+```
+
+## Example Script
+
+See the `examples/wes_platform_example.py` script for a complete example of using the WES platform implementation.
+
+## Configuration
+
+The WES platform can be configured using the following environment variables:
+
+- `WES_API_ENDPOINT`: The URL of the WES API endpoint
+- `WES_AUTH_TOKEN`: Authentication token for the WES API
+
diff --git a/examples/wes_platform_example.py b/examples/wes_platform_example.py
new file mode 100644
index 00000000..cd78c46a
--- /dev/null
+++ b/examples/wes_platform_example.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+'''
+Example script demonstrating how to use the WES Platform implementation
+'''
+import json
+import sys
+import time
+import logging
+import argparse
+
+from cwl_platform import PlatformFactory
+
+def main():
+    '''
+    Main function
+    '''
+    # Set up logging
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    logger = logging.getLogger(__name__)
+
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='WES Platform Example')
+    parser.add_argument('--api-endpoint', required=True, help='WES API endpoint URL')
+    parser.add_argument('--auth-token', help='Authentication token for the WES API')
+    parser.add_argument('--workflow', required=True, help='Path to workflow file or URL')
+    parser.add_argument('--params', required=True, help='Path to workflow parameters JSON file')
+    args = parser.parse_args()
+
+    # Initialize the platform factory
+    factory = PlatformFactory()
+
+    try:
+        # Get the WES platform
+        platform = factory.get_platform('WES')
+        logger.info("Initialized WES platform")
+
+        # Connect to the WES API
+        connected = platform.connect(
+            api_endpoint=args.api_endpoint,
+            auth_token=args.auth_token
+        )
+
+        if not connected:
+            logger.error("Failed to connect to WES API")
+            return 1
+
+        logger.info("Connected to WES API")
+
+        # Create a virtual project (not used by WES but required by the API)
+        project = platform.create_project('wes-example', 'WES Example Project')
+        logger.info("Created virtual project: %s", project['name'])
+
+        # Load workflow parameters
+        with open(args.params, 'r', encoding='utf-8') as f:
+            parameters = json.load(f)
+
+        # Submit the workflow
+        task = platform.submit_task(
+            name="WES Example Task",
+            project=project,
+            workflow=args.workflow,
+            parameters=parameters
+        )
+
+        if not task:
+            logger.error("Failed to submit workflow")
+            return 1
+
+        logger.info("Submitted workflow with run ID: %s", task.run_id)
+
+        # Monitor the workflow execution
+        while True:
+            state = platform.get_task_state(task, refresh=True)
+            logger.info("Workflow state: %s", state)
+
+            if state in ['Complete', 'Failed', 'Cancelled']:
+                break
+
+            time.sleep(10)  # Check every 10 seconds
+
+        # Get the workflow outputs
+        if state == 'Complete':
+            outputs = platform.get_task_outputs(task)
+            logger.info("Workflow completed successfully")
+            logger.info("Outputs: %s", outputs)
+            return 0
+
+        logger.error("Workflow failed or was cancelled")
+        return 1
+
+    except Exception as e: # pylint: disable=broad-except
+        logger.exception("Error: %s", e)
+        return 1
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/src/cwl_platform/__init__.py b/src/cwl_platform/__init__.py
index 25fc722f..ea8de73f 100644
--- a/src/cwl_platform/__init__.py
+++ b/src/cwl_platform/__init__.py
@@ -6,13 +6,15 @@
 
 from .arvados_platform import ArvadosPlatform
 from .sevenbridges_platform import SevenBridgesPlatform
+from .ngs360_platform import NGS360Platform
 #from .omics_platform import OmicsPlatform
 
 # Move this for a config file
 SUPPORTED_PLATFORMS = {
     'Arvados': ArvadosPlatform,
 #    'Omics': OmicsPlatform,
-    'SevenBridges': SevenBridgesPlatform
+    'SevenBridges': SevenBridgesPlatform,
+    'NGS360': NGS360Platform
 }
 
 class PlatformFactory():
diff --git a/src/cwl_platform/ngs360_platform.py b/src/cwl_platform/ngs360_platform.py
new file mode 100644
index 00000000..ec11e18a
--- /dev/null
+++ b/src/cwl_platform/ngs360_platform.py
@@ -0,0 +1,725 @@
+"""
+NGS360 / GA4GH WES Platform class
+
+This module implements the Platform abstract base class using the GA4GH Workflow Execution Service (WES) API.
+The WES API provides a standard way to submit and manage workflows across different workflow execution systems.
+"""
+
+import os
+import json
+import logging
+from urllib.parse import urljoin
+import requests
+
+from .base_platform import Platform
+
+
+class WESTask:
+    """
+    WES Task class to encapsulate task functionality
+    """
+
+    def __init__(self, run_id, name, **kwargs):
+        self.run_id = run_id
+        self.name = name
+        self.state = kwargs.get("state")
+        self.outputs = kwargs.get("outputs") or {}
+        self.inputs = kwargs.get("inputs") or {}
+
+    def to_dict(self):
+        """Convert to dictionary"""
+        return {
+            "run_id": self.run_id,
+            "name": self.name,
+            "state": self.state,
+            "outputs": self.outputs,
+            "inputs": self.inputs,
+        }
+
+    @classmethod
+    def from_dict(cls, task_dict):
+        """Convert from dictionary"""
+        return cls(
+            task_dict["run_id"],
+            task_dict["name"],
+            state=task_dict.get("state"),
+            outputs=task_dict.get("outputs"),
+            inputs=task_dict.get("inputs"),
+        )
+
+class NGS360Project():
+    """
+    NGS360 Project class to encapsulate project functionality
+    """
+
+    def __init__(self, project_id, name):
+        self.project_id = project_id
+        self.name = name
+
+
+class NGS360Platform(Platform):
+    """ NGS360 + GA4GH WES Platform class """
+
+    # WES API state mapping to Platform states
+    STATE_MAP = {
+        "UNKNOWN": "Unknown",
+        "QUEUED": "Queued",
+        "INITIALIZING": "Queued",
+        "RUNNING": "Running",
+        "PAUSED": "Running",
+        "COMPLETE": "Complete",
+        "EXECUTOR_ERROR": "Failed",
+        "SYSTEM_ERROR": "Failed",
+        "CANCELED": "Cancelled",
+        "CANCELING": "Cancelled",
+    }
+
+    def __init__(self, name):
+        """
+        Initialize WES Platform
+        """
+        super().__init__(name)
+        self.logger = logging.getLogger(__name__)
+        self.api_endpoint = None
+        self._auth_config = {}
+        self.projects = {}  # Map project names to project objects
+        self.workflows = {}  # Map workflow names to workflow objects
+        self.files = {}  # Map file paths to file objects
+
+    def connect(self, **kwargs):
+        """
+        Connect to the WES API
+
+        :param kwargs: Connection parameters
+            - api_endpoint: WES API endpoint URL
+            - auth_token: Authentication token for the WES API
+        """
+        self.api_endpoint = kwargs.get("api_endpoint", os.environ.get("WES_API_ENDPOINT"))
+        if not self.api_endpoint:
+            raise ValueError("WES API endpoint URL is required")
+
+        # Set up auth token or username/password as auth
+        auth_token = kwargs.get("auth_token", os.environ.get("WES_AUTH_TOKEN"))
+        if auth_token:
+            self._auth_config['token'] = auth_token
+        else:
+            username = os.environ.get("WES_USERNAME")
+            password = os.environ.get("WES_PASSWORD")
+            self._auth_config['credentials'] = (username, password)
+
+        # Test connection by getting service info
+        try:
+            response = self._make_request("GET", "service-info")
+            self.logger.info(
+                "Connected to WES API: %s",
+                response.get('workflow_type_versions', {})
+            )
+            self.connected = True
+            # return True
+        except requests.RequestException as e:
+            self.logger.error("Failed to connect to WES API: %s", e)
+            self.connected = False
+            return False
+        except (ValueError, KeyError) as e:
+            self.logger.error("Invalid response from WES API: %s", e)
+            self.connected = False
+            return False
+
+        self.ngs360_endpoint = kwargs.get("ngs360_endpoint", os.environ.get("NGS360_API_ENDPOINT"))
+        if not self.ngs360_endpoint:
+            raise ValueError("NGS360 API endpoint URL is required")
+        try:
+            response = requests.get(
+                f"{self.ngs360_endpoint}/",
+                timeout=30
+            )
+            response.raise_for_status()
+            self.logger.info("Connected to NGS360 API")
+            return True
+        except requests.RequestException as e:
+            self.logger.error("Failed to connect to NGS360 API: %s", e)
+            self.connected = False
+            return False
+
+    def _make_request(self, method, path, **kwargs):
+        """
+        Make a request to the WES API
+
+        :param method: HTTP method (GET, POST, etc.)
+        :param path: API path
+        :param data: Request data
+        :param files: Files to upload
+        :param params: Query parameters
+        :return: Response JSON
+        """
+        # Ensure path doesn't start with a slash to avoid urljoin issues
+        if path.startswith("/"):
+            path = path[1:]
+
+        # Make sure the API endpoint ends with a slash for proper joining
+        endpoint = self.api_endpoint
+        if not endpoint.endswith("/"):
+            endpoint = endpoint + "/"
+
+        url = urljoin(endpoint, path)
+        headers = {}
+        auth = None
+
+        if 'token' in self._auth_config:
+            headers["Authorization"] = f"Bearer {self._auth_config['token']}"
+        elif 'credentials' in self._auth_config:
+            auth = self._auth_config['credentials']
+
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            data=kwargs.get('data'),
+            files=kwargs.get('files'),
+            params=kwargs.get('params'),
+            auth=auth,
+            timeout=120
+        )
+
+        response.raise_for_status()
+
+        if response.content:
+            return response.json()
+
+        return {}
+
+    # File methods
+    def copy_folder(self, source_project, source_folder, destination_project):
+        """
+        Copy source folder to destination project
+
+        Note: WES API doesn't have a direct concept of folders, so this is a no-op
+        """
+        self.logger.warning("WES API doesn't support folder operations directly")
+
+    def download_file(self, file, dest_folder):
+        """
+        Download a file to a local directory
+
+        :param file: File ID to download
+        :param dest_folder: Destination folder to download file to
+        :return: Name of local file downloaded or None
+        """
+        if not file or not dest_folder:
+            return None
+
+        # In WES context, file might be a URL
+        if file.startswith("http"):
+            filename = os.path.basename(file)
+            dest_path = os.path.join(dest_folder, filename)
+
+            response = requests.get(file, stream=True, timeout=120)
+            response.raise_for_status()
+
+            with open(dest_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+
+            return dest_path
+
+        self.logger.error("Unsupported file format: %s", file)
+        return None
+
+    def export_file(self, file, bucket_name, prefix):
+        """
+        Use platform specific functionality to copy a file from a platform to an S3 bucket.
+
+        :param file: File to export
+        :param bucket_name: S3 bucket name
+        :param prefix: Destination S3 folder to export file to, path/to/folder
+        :return: s3 file path or None
+        """
+        self.logger.warning("WES API doesn't support direct S3 export")
+
+    def get_file_id(self, project, file_path):
+        """
+        Get a file id by its full path name
+
+        Note: WES API doesn't have a direct concept of files, so this returns the path
+        """
+        return file_path
+
+    def get_files(self, project, filters=None):
+        """
+        Retrieve files in a project matching the filter criteria
+
+        Note: WES API doesn't have a direct concept of files, so this returns an empty list
+
+        :param project: Project to search for files
+        :param filters: Dictionary containing filter criteria
+        :return: List of tuples (file path, file object) matching filter criteria
+        """
+        self.logger.warning("WES API doesn't support listing files")
+        return []
+
+    def get_folder_id(self, project, folder_path):
+        """
+        Get a folder id by its full path name
+
+        Note: WES API doesn't have a direct concept of folders, so this returns None
+        """
+        return folder_path
+
+    def rename_file(self, fileid, new_filename):
+        """
+        Rename a file to new_filename.
+
+        Note: WES API doesn't have a direct concept of files, so this is a no-op
+        """
+        self.logger.warning("WES API doesn't support file operations")
+
+    def roll_file(self, project, file_name):
+        """
+        Roll (find and rename) a file in a project.
+
+        Note: WES API doesn't have a direct concept of files, so this is a no-op
+        """
+        self.logger.warning("WES API doesn't support file operations")
+
+    def stage_output_files(self, project, output_files):
+        """
+        Stage output files to a project
+
+        Note: WES API doesn't have a direct concept of files, so this is a no-op
+        """
+        self.logger.warning("WES API doesn't support file staging operations")
+
+    def upload_file(
+        self,
+        filename,
+        project,
+        dest_folder=None,
+        destination_filename=None,
+        overwrite=False,
+    ):
+        """
+        Upload a local file to project
+
+        Note: WES API doesn't have a direct concept of files, so this returns the filename
+
+        :param filename: filename of local file to be uploaded.
+        :param project: project that the file is uploaded to.
+        :param dest_folder: The target path to the folder that file will be uploaded to. None will upload to root.
+        :param destination_filename: File name after uploaded to destination folder.
+        :param overwrite: Overwrite the file if it already exists.
+        :return: ID of uploaded file.
+        """
+        with open(filename, "rb") as f:
+            response = requests.post(
+                f"{self.ngs360_endpoint}/api/v1/files",
+                data={
+                    "filename": filename,
+                    "entity_type": 'project',
+                    "entity_id": project["project_id"],
+                    "relative_path": dest_folder,
+                    "destination_filename": destination_filename or os.path.basename(filename),
+                    "overwrite": overwrite,
+                },
+                files={"content": f},
+            )
+
+        if response.status_code == 201:
+            file_info = response.json()
+            return f"ngs360://{file_info['file_id']}"
+        else:
+            self.logger.error(f"Error uploading file: {response.status_code}")
+            self.logger.error(response.json())
+            return None
+
+    # Task/Workflow methods
+    def copy_workflow(self, src_workflow, destination_project):
+        """
+        Copy a workflow from one project to another
+
+        Note: WES API doesn't have a direct concept of projects, so this returns the workflow
+        """
+        return src_workflow
+
+    def copy_workflows(self, reference_project, destination_project):
+        """
+        Copy all workflows from the reference_project to project
+
+        Note: WES API doesn't have a direct concept of projects, so this returns an empty list
+        """
+        return []
+
+    def get_workflows(self, project):
+        """
+        Get workflows in a project
+
+        Note: WES API doesn't have a direct concept of projects, so this returns an empty list
+        """
+        return []
+
+    def delete_task(self, task):
+        """
+        Delete a task/workflow/process
+
+        :param task: WESTask object
+        :return: True if successful, False otherwise
+        """
+        if not task or not hasattr(task, "run_id"):
+            return False
+
+        try:
+            self._make_request("DELETE", f"runs/{task.run_id}")
+            return True
+        except requests.RequestException as e:
+            self.logger.error("Failed to delete task: %s", e)
+            return False
+
+    def get_current_task(self):
+        """
+        Get the current task
+
+        Note: WES API doesn't have a concept of current task, so this returns None
+        """
+        return None
+
+    def get_task_cost(self, task):
+        """
+        Return task cost
+
+        Note: WES API doesn't provide cost information, so this returns None
+        """
+        return None
+
+    def get_task_input(self, task, input_name):
+        """
+        Retrieve the input field of the task
+
+        :param task: WESTask object
+        :param input_name: Name of the input field
+        :return: Value of the input field or None
+        """
+        if not task or not hasattr(task, "inputs"):
+            return None
+
+        return task.inputs.get(input_name)
+
+    def get_task_state(self, task, refresh=False):
+        """
+        Get workflow/task state
+
+        :param task: WESTask object
+        :param refresh: Refresh task state before returning (Default: False)
+        :return: The state of the task (Queued, Running, Complete, Failed, Cancelled)
+        """
+        if not task or not hasattr(task, "run_id"):
+            return "Unknown"
+
+        if refresh:
+            try:
+                response = self._make_request("GET", f"runs/{task.run_id}")
+                wes_state = response.get("state", "UNKNOWN")
+                task.state = self.STATE_MAP.get(wes_state, "Unknown")
+                task.outputs = response.get("outputs", {})
+            except requests.RequestException as e:
+                self.logger.error("Failed to refresh task state: %s", e)
+                return "Unknown"
+            except (ValueError, KeyError) as e:
+                self.logger.error("Invalid response format for task state: %s", e)
+                return "Unknown"
+
+        return task.state or "Unknown"
+
+    def get_task_output(self, task, output_name):
+        """
+        Retrieve the output field of the task
+
+        :param task: WESTask object
+        :param output_name: Name of the output field
+        :return: Value of the output field or None
+        """
+        if not task or not hasattr(task, "run_id"):
+            return None
+        try:
+            response = self._make_request("GET", f"runs/{task.run_id}")
+            task.outputs = response.get("outputs", {})
+            task.output_mapping = task.outputs.get("output_mapping",{})
+            return task.output_mapping.get(output_name)
+        except requests.RequestException as e:
+            self.logger.error("Failed to get task output: %s", e)
+            return None
+        except (ValueError, KeyError, AttributeError) as e:
+            self.logger.error("Invalid response format for task output: %s", e)
+            return None
+
+    def get_task_outputs(self, task):
+        """
+        Return a list of output fields of the task
+
+        :param task: WESTask object
+        :return: Dictionary of output fields
+        """
+        if not task or not hasattr(task, "run_id"):
+            return None
+        try:
+            response = self._make_request("GET", f"runs/{task.run_id}")
+            task.outputs = response.get("outputs", {})
+            task.output_mapping = task.outputs.get("output_mapping",{})
+        except requests.RequestException as e:
+            self.logger.error("Failed to get task outputs: %s", e)
+            return []
+        except (ValueError, KeyError, AttributeError) as e:
+            self.logger.error("Invalid response format for task outputs: %s", e)
+            return []
+
+        return list(task.output_mapping.keys())
+
+    def get_task_output_filename(self, task, output_name):
+        """
+        Retrieve the output field of the task and return filename
+        NOTE: This method is deprecated as of v0.2.5 of PAML.  Will be removed in v1.0.
+
+        :param task: WESTask object
+        :param output_name: Name of the output field
+        :return: Filename of the output field or None
+        """
+        output = self.get_task_output(task, output_name)
+        if not output:
+            return None
+
+        # If output is a URL, extract the filename
+        if isinstance(output, list):
+            return [output_path.split('/')[-1] for output_path in output]
+
+        return output.split('/')[-1]
+
+    def get_tasks_by_name(self, project, task_name=None, inputs_to_compare=None, tasks=None):
+        """
+        Get all processes/tasks in a project with a specified name
+
+        :param project: The project to search
+        :param task_name: The name of the process to search for (if None return all tasks)
+        :return: List of tasks
+        """
+        try:
+            tags = {"ProjectId": project["project_id"]}
+            if task_name:
+                tags["TaskName"] = task_name
+            params = {
+                "tags": json.dumps(tags)
+            }
+            response = self._make_request("GET", "runs", params=params)
+            tasks = []
+
+            for run in response.get("runs", []):
+                task = WESTask(
+                    run_id=run.get("run_id"),
+                    name=run.get("name", ""),
+                    state=self.STATE_MAP.get(run.get("state", "UNKNOWN"), "Unknown"),
+                )
+                tasks.append(task)
+
+            return tasks
+        except requests.RequestException as e:
+            self.logger.error("Failed to get tasks: %s", e)
+            return []
+        except (ValueError, KeyError, TypeError) as e:
+            self.logger.error("Invalid response format for tasks: %s", e)
+            return []
+
+    def stage_task_output(self, task, project, output_to_export, output_directory_name):
+        """
+        DEPRECATED: Use stage_output_files instead
+
+        Prepare/Copy output files of a task for export.
+
+        Note: WES API doesn't have a direct concept of files, so this is a no-op
+        """
+        self.logger.warning("WES API doesn't support file staging operations")
+
+    def submit_task(self, name, project, workflow, parameters, execution_settings=None):
+        """
+        Submit a workflow to the GA4GH WES API
+
+        :param name: Name of the task to submit
+        :param project: Project to submit the task to
+        :param workflow: Workflow to submit (ID, URL or file path to the workflow)
+        :param parameters: Parameters for the workflow
+        :param execution_settings: Not used in NGS360 WES API (yet)
+        :return: WESTask object or None
+        """
+        if not workflow:
+            self.logger.error("Workflow is required")
+            return None
+
+        # Prepare the request data
+        workflow_url = workflow
+        workflow_type = "CWL"  # Default to CWL
+        workflow_type_version = "v1.0"  # Default to v1.0
+
+        # Check if workflow is a file path or URL
+        if os.path.exists(workflow):
+            # For WES, we need to upload the workflow file
+            workflow_type = "CWL"  # Assuming CWL, adjust as needed
+            with open(workflow, "rb") as f:
+                workflow_content = f.read()
+
+            files = {
+                "workflow_attachment": (os.path.basename(workflow), workflow_content)
+            }
+            workflow_url = os.path.basename(workflow)
+        else:
+            files = None
+
+        # Prepare the request data
+        data = {
+            "workflow_params": json.dumps(parameters),
+            "workflow_type": workflow_type,
+            "workflow_type_version": workflow_type_version,
+            "workflow_url": workflow_url,
+            "tags": json.dumps({
+                "ProjectId": project["project_id"],
+                "TaskName": name,
+            }),
+        }
+        try:
+            response = self._make_request("POST", "runs", data=data, files=files)
+            run_id = response.get("run_id")
+
+            if not run_id:
+                self.logger.error("Failed to submit task: No run_id returned")
+                return None
+
+            # Create a WESTask object
+            task = WESTask(run_id=run_id, name=name, state="Queued", inputs=parameters)
+
+            return task
+        except requests.RequestException as e:
+            self.logger.error("Failed to submit task: %s", e)
+            return None
+        except (ValueError, KeyError, IOError) as e:
+            self.logger.error("Failed to prepare or parse task submission: %s", e)
+            return None
+
+    # Project methods
+    def create_project(self, project_name, project_description, **kwargs):
+        """
+        Create a project
+
+        Note: WES API doesn't have a concept of projects, so this creates a virtual project
+
+        :param project_name: Name of the project
+        :param project_description: Description of the project
+        :param kwargs: Additional arguments for creating a project
+        :return: Project object
+        """
+        project = {
+            # "id": str(uuid.uuid4()),
+            "name": project_name,
+            "description": project_description,
+        }
+        self.projects[project_name] = project
+        return project
+
+    def delete_project_by_name(self, project_name):
+        """
+        Delete a project on the platform
+
+        Note: WES API doesn't have a concept of projects, so this removes the virtual project
+        """
+        if project_name in self.projects:
+            del self.projects[project_name]
+            return True
+        return False
+
+    def get_project(self):
+        """
+        Determine what project we are running in
+
+        Note: WES API doesn't have a concept of projects, so this returns None
+        """
+        return None
+
+    def get_project_by_name(self, project_name):
+        """
+        Get a project by its name
+        """
+        response = requests.get(
+            f"{self.ngs360_endpoint}/api/v1/projects/search?query={project_name}",
+            timeout=30
+        )
+        if response.status_code == 200:
+            projects = response.json().get("data", [])
+            for project in projects:
+                if project.get("name") == project_name:
+                    return project
+            self.logger.error(f"Project '{project_name}' not found")
+            return None
+
+    def get_project_by_id(self, project_id):
+        """
+        Get a project by its id
+
+        """
+        response = requests.get(
+            f"{self.ngs360_endpoint}/api/v1/projects/{project_id}",
+            timeout=30
+        )
+        if response.status_code == 200:
+            return response.json()
+        else:
+            self.logger.error(f"Error retrieving project: {response.status_code}")
+            self.logger.error(response.json())
+            return None
+
+    def get_project_cost(self, project):
+        """
+        Return project cost
+
+        Note: WES API doesn't provide cost information, so this returns None
+        """
+        return None
+
+    def get_project_users(self, project):
+        """
+        Return a list of user objects associated with a project
+
+        Note: WES API doesn't have a concept of projects, so this returns an empty list
+        """
+        return []
+
+    def get_projects(self):
+        """
+        Get list of all projects
+
+        Note: WES API doesn't have a concept of projects, so this returns the virtual projects
+        """
+        return list(self.projects.values())
+
+    # User methods
+    def add_user_to_project(self, platform_user, project, permission):
+        """
+        Add a user to a project on the platform
+
+        Note: WES API doesn't have a concept of projects, so this is a no-op
+        """
+        self.logger.warning("WES API doesn't support user management")
+
+    def get_user(self, user):
+        """
+        Get a user object from their (platform) user id or email address
+
+        Note: WES API doesn't have a concept of users, so this returns None
+        """
+        return None
+
+    @classmethod
+    def detect(cls):
+        """
+        Detect platform we are running on
+
+        Note: This method checks if we're running in a WES environment
+        """
+        # Check if WES API endpoint is set in environment variables
+        wes_api_endpoint = os.environ.get("WES_API_ENDPOINT")
+        if wes_api_endpoint:
+            return True
+        return False
diff --git a/tests/test_ngs360-ga4gh_platform.py b/tests/test_ngs360-ga4gh_platform.py
new file mode 100644
index 00000000..936464e8
--- /dev/null
+++ b/tests/test_ngs360-ga4gh_platform.py
@@ -0,0 +1,344 @@
+'''
+Test WES Platform implementation
+'''
+import json
+import unittest
+from unittest.mock import patch, MagicMock
+
+from src.cwl_platform.ngs360_platform import NGS360Platform, WESTask
+
+class TestNGS360Platform(unittest.TestCase):
+    '''
+    Test WES Platform implementation
+    '''
+    def setUp(self):
+        '''
+        Set up test environment
+        '''
+        self.platform = NGS360Platform('WES')
+        self.platform.api_endpoint = 'https://wes.example.com/ga4gh/wes/v1'
+        self.platform._auth_config['token'] = 'test_token'
+        self.platform.connected = True
+
+    @patch('requests.request')
+    def test_make_request(self, mock_request):
+        '''
+        Test _make_request method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content = json.dumps({'key': 'value'}).encode('utf-8')
+        mock_response.json.return_value = {'key': 'value'}
+        mock_request.return_value = mock_response
+
+        # Test GET request
+        result = self.platform._make_request('GET', 'service-info') # pylint: disable=protected-access
+        mock_request.assert_called_with(
+            method='GET',
+            url='https://wes.example.com/ga4gh/wes/v1/service-info',
+            headers={'Authorization': 'Bearer test_token'},
+            data=None,
+            files=None,
+            params=None,
+            timeout=120,
+            auth=None
+        )
+        self.assertEqual(result, {'key': 'value'})
+
+    @patch('requests.request')
+    def test_connect(self, mock_request):
+        '''
+        Test connect method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content = json.dumps({
+            'workflow_type_versions': {
+                'CWL': {'workflow_type_version': ['v1.0']}
+            }
+        }).encode('utf-8')
+        mock_response.json.return_value = {
+            'workflow_type_versions': {
+                'CWL': {'workflow_type_version': ['v1.0']}
+            }
+        }
+        mock_request.return_value = mock_response
+
+        # Test connect
+        platform = NGS360Platform('WES')
+        result = platform.connect(api_endpoint='https://wes.example.com/ga4gh/wes/v1', auth_token='test_token')
+        self.assertTrue(result)
+        self.assertTrue(platform.connected)
+        self.assertEqual(platform.api_endpoint, 'https://wes.example.com/ga4gh/wes/v1')
+        self.assertEqual(platform._auth_config['token'], 'test_token')
+
+    @patch('requests.request')
+    def test_submit_task(self, mock_request):
+        '''
+        Test submit_task method calls the GA4GH API correctly
+        '''
+        # Set up parameters
+        workflow_url = 'workflow_id'
+        workflow_parameters = {'input': 'value'}
+
+        # Mock the GA4GH response for submit_task
+        mock_response = MagicMock()
+        mock_response.json.return_value = {'run_id': 'test_run_id'}
+        mock_request.return_value = mock_response
+
+        # Test
+        task = self.platform.submit_task(
+            name='Test Task',
+            project={'id': "P-1234567", 'name': 'Test Project'},
+            workflow=workflow_url,
+            parameters=workflow_parameters,
+            execution_settings={"use_spot_instance": False}
+        )
+
+        # Verify GA4GH API request withing submit_task was made correctly
+        mock_request.assert_called_with(
+            method='POST',
+            url='https://wes.example.com/ga4gh/wes/v1/runs',
+            headers={'Authorization': 'Bearer test_token'},
+            data={
+                'workflow_params': json.dumps(workflow_parameters),
+                'workflow_type': 'CWL',
+                'workflow_type_version': 'v1.0',
+                'workflow_url': workflow_url,
+                'tags': '{"ProjectName": "Test Project", "TaskName": "Test Task"}'
+            },
+            files=None,
+            params=None,
+            timeout=120,
+            auth=None
+        )
+
+        # Verify task
+        self.assertIsNotNone(task)
+        self.assertEqual(task.run_id, 'test_run_id')
+        self.assertEqual(task.name, 'Test Task')
+        self.assertEqual(task.state, 'Queued')
+        self.assertEqual(task.inputs, workflow_parameters)
+
+    @patch('requests.request')
+    def test_get_task_state(self, mock_request):
+        '''
+        Test get_task_state method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content = json.dumps({
+            'run_id': 'test_run_id',
+            'state': 'RUNNING',
+            'outputs': {'output': 'value'}
+        }).encode('utf-8')
+        mock_response.json.return_value = {
+            'run_id': 'test_run_id',
+            'state': 'RUNNING',
+            'outputs': {'output': 'value'}
+        }
+        mock_request.return_value = mock_response
+
+        # Create task
+        task = WESTask('test_run_id', 'Test Task')
+
+        # Test get_task_state with refresh
+        state = self.platform.get_task_state(task, refresh=True)
+        self.assertEqual(state, 'Running')
+        self.assertEqual(task.state, 'Running')
+        self.assertEqual(task.outputs, {'output': 'value'})
+
+        # Verify request
+        mock_request.assert_called_with(
+            method='GET',
+            url='https://wes.example.com/ga4gh/wes/v1/runs/test_run_id',
+            headers={'Authorization': 'Bearer test_token'},
+            data=None,
+            files=None,
+            params=None,
+            timeout=120,
+            auth=None
+        )
+
+    @patch('requests.request')
+    def test_get_task_output(self, mock_request):
+        '''
+        Test get_task_output method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content  = json.dumps({
+            "outputs": {
+                "output_mapping":  {
+                    'output': 'value'
+                }
+            }
+        }).encode('utf-8')
+        mock_response.json.return_value = {
+            "outputs": {
+                "output_mapping":  {
+                    'output': 'value'
+                }
+            }
+        }
+        mock_request.return_value = mock_response
+
+        # Create task with outputs
+        task = WESTask('test_run_id', 'Test Task')
+
+        # Test get_task_output
+        output = self.platform.get_task_output(task, 'output')
+        self.assertEqual(output, 'value')
+
+        # Test get_task_output with non-existent output
+        output = self.platform.get_task_output(task, 'non_existent')
+        self.assertIsNone(output)
+
+    @patch('requests.request')
+    def test_get_task_outputs(self, mock_request):
+        '''
+        Test get_task_outputs method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content  = json.dumps({
+            "outputs": {
+                "output_mapping":  {
+                    'output1': 'value1',
+                    'output2': 'value2'
+                }
+            }
+        }).encode('utf-8')
+        mock_response.json.return_value = {
+            "outputs": {
+                "output_mapping":  {
+                    'output1': 'value1',
+                    'output2': 'value2'
+                }
+            }
+        }
+        mock_request.return_value = mock_response
+        # Create task with outputs
+        task = WESTask('test_run_id', 'Test Task', outputs={'output1': 'value1', 'output2': 'value2'})
+
+        # Test get_task_outputs
+        outputs = self.platform.get_task_outputs(task)
+        self.assertEqual(outputs, ['output1', 'output2'])
+
+    @patch('requests.request')
+    def test_get_tasks_by_name(self, mock_request):
+        '''
+        Test get_tasks_by_name method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content = json.dumps({
+            'runs': [
+                {
+                    'run_id': 'run1',
+                    'name': 'Task 1',
+                    'state': 'COMPLETE'
+                },
+                {
+                    'run_id': 'run2',
+                    'name': 'Task 2',
+                    'state': 'RUNNING'
+                }
+            ]
+        }).encode('utf-8')
+        mock_response.json.return_value = {
+            'runs': [
+                {
+                    'run_id': 'run1',
+                    'name': 'Task 1',
+                    'state': 'COMPLETE'
+                },
+                {
+                    'run_id': 'run2',
+                    'name': 'Task 2',
+                    'state': 'RUNNING'
+                }
+            ]
+        }
+        mock_request.return_value = mock_response
+
+        # Test get_tasks_by_name
+        project = {'id': 'test_project', 'name': 'Test Project'}
+        tasks = self.platform.get_tasks_by_name(project)
+
+        # Verify request
+        mock_request.assert_called_with(
+            method='GET',
+            url='https://wes.example.com/ga4gh/wes/v1/runs',
+            headers={'Authorization': 'Bearer test_token'},
+            data=None,
+            files=None,
+            params={'tags': '{"ProjectName": "Test Project"}'},
+            timeout=120,
+            auth=None
+        )
+
+        # Verify tasks
+        self.assertEqual(len(tasks), 2)
+        self.assertEqual(tasks[0].run_id, 'run1')
+        self.assertEqual(tasks[0].name, 'Task 1')
+        self.assertEqual(tasks[0].state, 'Complete')
+        self.assertEqual(tasks[1].run_id, 'run2')
+        self.assertEqual(tasks[1].name, 'Task 2')
+        self.assertEqual(tasks[1].state, 'Running')
+
+    @patch('requests.request')
+    def test_delete_task(self, mock_request):
+        '''
+        Test delete_task method
+        '''
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.content = b''
+        mock_request.return_value = mock_response
+
+        # Create task
+        task = WESTask('test_run_id', 'Test Task')
+
+        # Test delete_task
+        result = self.platform.delete_task(task)
+        self.assertTrue(result)
+
+        # Verify request
+        mock_request.assert_called_with(
+            method='DELETE',
+            url='https://wes.example.com/ga4gh/wes/v1/runs/test_run_id',
+            headers={'Authorization': 'Bearer test_token'},
+            data=None,
+            files=None,
+            params=None,
+            timeout=120,
+            auth=None
+        )
+
+    def test_project_methods(self):
+        '''
+        Test project methods
+        '''
+        # Test create_project
+        project = self.platform.create_project('Test Project', 'Test Description')
+        self.assertEqual(project['name'], 'Test Project')
+        self.assertEqual(project['description'], 'Test Description')
+
+        # Test get_project_by_name
+        project2 = self.platform.get_project_by_name('Test Project')
+        self.assertEqual(project2['name'], 'Test Project')
+        self.assertEqual(project2['description'], 'Test Description')
+
+        # Test get_projects
+        projects = self.platform.get_projects()
+        self.assertEqual(len(projects), 1)
+        self.assertEqual(projects[0]['name'], 'Test Project')
+
+        # Test delete_project_by_name
+        result = self.platform.delete_project_by_name('Test Project')
+        self.assertTrue(result)
+        self.assertEqual(len(self.platform.projects), 0)
+
+if __name__ == '__main__':
+    unittest.main()