diff --git a/src/Api/ExportRequestDataMessage.cs b/src/Api/ExportRequestDataMessage.cs
old mode 100644
new mode 100755
index 2c87e729f..6246f93db
--- a/src/Api/ExportRequestDataMessage.cs
+++ b/src/Api/ExportRequestDataMessage.cs
@@ -47,6 +47,11 @@ public string ExportTaskId
             get { return _exportRequest.ExportTaskId; }
         }
 
+        public string WorkflowInstanceId
+        {
+            get { return _exportRequest.WorkflowInstanceId; }
+        }
+
         public string CorrelationId
         {
             get { return _exportRequest.CorrelationId; }
diff --git a/src/Api/Storage/RemoteAppExecution.cs b/src/Api/Storage/RemoteAppExecution.cs
new file mode 100755
index 000000000..79d9542b3
--- /dev/null
+++ b/src/Api/Storage/RemoteAppExecution.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using FellowOakDicom;
+using Monai.Deploy.Messaging.Events;
+
+namespace Monai.Deploy.InformaticsGateway.Api.Storage
+{
+    public class RemoteAppExecution
+    {
+        public DateTime RequestTime { get; set; } = DateTime.UtcNow;
+        public string ExportTaskId { get; set; } = string.Empty;
+        public string WorkflowInstanceId { get; set; } = string.Empty;
+        public string CorrelationId { get; set; } = string.Empty;
+        public string? StudyUid { get; set; }
+        public string? OutgoingStudyUid { get; set; }
+        public List<DestinationApplicationEntity> ExportDetails { get; set; } = new();
+        public List<string> Files { get; set; } = new();
+        public FileExportStatus Status { get; set; }
+        public Dictionary<DicomTag, string> OriginalValues { get; set; } = new();
+    }
+}
diff --git a/src/Client/Test/packages.lock.json b/src/Client/Test/packages.lock.json
old mode 100644
new mode 100755
diff --git a/src/Database/Api/Repositories/IRemoteAppExecutionRepository.cs b/src/Database/Api/Repositories/IRemoteAppExecutionRepository.cs
new file mode 100755
index 000000000..c6897a56c
--- /dev/null
+++ b/src/Database/Api/Repositories/IRemoteAppExecutionRepository.cs
@@ -0,0 +1,14 @@
+
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+
+namespace Monai.Deploy.InformaticsGateway.Database.Api.Repositories
+{
+    public interface IRemoteAppExecutionRepository
+    {
+        Task<bool> AddAsync(RemoteAppExecution item, CancellationToken cancellationToken = default);
+
+        Task<RemoteAppExecution?> GetAsync(string OutgoingStudyUid, CancellationToken cancellationToken = default);
+
+        Task<int> RemoveAsync(string OutgoingStudyUid, CancellationToken cancellationToken = default);
+    }
+}
diff --git a/src/Database/DatabaseManager.cs b/src/Database/DatabaseManager.cs
old mode 100644
new mode 100755
index 05191d1b2..4a297f588
--- a/src/Database/DatabaseManager.cs
+++ b/src/Database/DatabaseManager.cs
@@ -78,6 +78,7 @@ public static IServiceCollection ConfigureDatabase(this IServiceCollection servi
                     services.AddScoped(typeof(IStorageMetadataRepository), typeof(EntityFramework.Repositories.StorageMetadataWrapperRepository));
                     services.AddScoped(typeof(IPayloadRepository), typeof(EntityFramework.Repositories.PayloadRepository));
                     services.AddScoped(typeof(IDicomAssociationInfoRepository), typeof(EntityFramework.Repositories.DicomAssociationInfoRepository));
+                    services.AddScoped(typeof(IRemoteAppExecutionRepository), typeof(EntityFramework.Repositories.RemoteAppExecutionRepository));
                     return services;
 
                 case DbType_MongoDb:
@@ -91,6 +92,7 @@ public static IServiceCollection ConfigureDatabase(this IServiceCollection servi
                     services.AddScoped(typeof(IStorageMetadataRepository), typeof(MongoDB.Repositories.StorageMetadataWrapperRepository));
                     services.AddScoped(typeof(IPayloadRepository), typeof(MongoDB.Repositories.PayloadRepository));
                     services.AddScoped(typeof(IDicomAssociationInfoRepository), typeof(MongoDB.Repositories.DicomAssociationInfoRepository));
+                    services.AddScoped(typeof(IRemoteAppExecutionRepository), typeof(MongoDB.Repositories.RemoteAppExecutionRepository));
 
                     return services;
 
diff --git a/src/Database/EntityFramework/Repositories/RemoteAppExecutionRepository.cs b/src/Database/EntityFramework/Repositories/RemoteAppExecutionRepository.cs
new file mode 100755
index 000000000..b7b9aaa78
--- /dev/null
+++ b/src/Database/EntityFramework/Repositories/RemoteAppExecutionRepository.cs
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2022 MONAI Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ardalis.GuardClauses;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Configuration;
+using Monai.Deploy.InformaticsGateway.Database.Api.Logging;
+using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
+using Polly;
+using Polly.Retry;
+
+namespace Monai.Deploy.InformaticsGateway.Database.EntityFramework.Repositories
+{
+    public class RemoteAppExecutionRepository : IRemoteAppExecutionRepository, IDisposable
+    {
+        private readonly ILogger<PayloadRepository> _logger;
+        private readonly IServiceScope _scope;
+        private readonly InformaticsGatewayContext _informaticsGatewayContext;
+        private readonly AsyncRetryPolicy _retryPolicy;
+        private readonly DbSet<RemoteAppExecution> _dataset;
+        private bool _disposedValue;
+
+        public RemoteAppExecutionRepository(
+            IServiceScopeFactory serviceScopeFactory,
+            ILogger<PayloadRepository> logger,
+            IOptions<InformaticsGatewayConfiguration> options)
+        {
+            Guard.Against.Null(serviceScopeFactory, nameof(serviceScopeFactory));
+            Guard.Against.Null(options, nameof(options));
+
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+            _scope = serviceScopeFactory.CreateScope();
+            _informaticsGatewayContext = _scope.ServiceProvider.GetRequiredService<InformaticsGatewayContext>();
+            _retryPolicy = Policy.Handle<Exception>().WaitAndRetryAsync(
+                options.Value.Database.Retries.RetryDelays,
+                (exception, timespan, count, context) => _logger.DatabaseErrorRetry(timespan, count, exception));
+            _dataset = _informaticsGatewayContext.Set<RemoteAppExecution>();
+        }
+
+        public async Task<bool> AddAsync(RemoteAppExecution item, CancellationToken cancellationToken = default)
+        {
+            Guard.Against.Null(item, nameof(item));
+
+            return await _retryPolicy.ExecuteAsync(async () =>
+            {
+                var result = await _dataset.AddAsync(item, cancellationToken).ConfigureAwait(false);
+                await _informaticsGatewayContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+                return true;
+            }).ConfigureAwait(false);
+        }
+
+        public async Task<int> RemoveAsync(string OriginalStudyUid, CancellationToken cancellationToken = default)
+        {
+            Guard.Against.Null(OriginalStudyUid, nameof(OriginalStudyUid));
+
+            return await _retryPolicy.ExecuteAsync(async () =>
+            {
+                var result = await _dataset.SingleOrDefaultAsync(p => p.OutgoingStudyUid == OriginalStudyUid).ConfigureAwait(false);
+                if (result is not null)
+                {
+                    _dataset.Remove(result);
+                    await _informaticsGatewayContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+                    return 1;
+                }
+                return 0;
+            }).ConfigureAwait(false);
+        }
+
+        public async Task<RemoteAppExecution?> GetAsync(string OutgoingStudyUid, CancellationToken cancellationToken = default)
+        {
+            Guard.Against.Null(OutgoingStudyUid, nameof(OutgoingStudyUid));
+
+            return await _retryPolicy.ExecuteAsync(async () =>
+            {
+                var result = await _dataset.SingleOrDefaultAsync(p => p.OutgoingStudyUid == OutgoingStudyUid).ConfigureAwait(false);
+                if (result is not null)
+                {
+                    return result;
+                }
+                return default;
+            }).ConfigureAwait(false);
+        }
+
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposedValue)
+            {
+                if (disposing)
+                {
+                    _informaticsGatewayContext.Dispose();
+                    _scope.Dispose();
+                }
+
+                _disposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}
diff --git a/src/Database/MongoDB/Repositories/RemoteAppExecutionRepository.cs b/src/Database/MongoDB/Repositories/RemoteAppExecutionRepository.cs
new file mode 100755
index 000000000..8fbf51348
--- /dev/null
+++ b/src/Database/MongoDB/Repositories/RemoteAppExecutionRepository.cs
@@ -0,0 +1,104 @@
+using Ardalis.GuardClauses;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Configuration;
+using Monai.Deploy.InformaticsGateway.Database.Api.Logging;
+using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
+using Monai.Deploy.InformaticsGateway.Database.MongoDB.Configurations;
+using MongoDB.Driver;
+using Polly;
+using Polly.Retry;
+
+namespace Monai.Deploy.InformaticsGateway.Database.MongoDB.Repositories
+{
+    public class RemoteAppExecutionRepository : IRemoteAppExecutionRepository, IDisposable
+    {
+        private readonly ILogger<RemoteAppExecutionRepository> _logger;
+        private readonly IServiceScope _scope;
+        private readonly AsyncRetryPolicy _retryPolicy;
+        private readonly IMongoCollection<RemoteAppExecution> _collection;
+        private bool _disposedValue;
+
+        public RemoteAppExecutionRepository(IServiceScopeFactory serviceScopeFactory,
+            ILogger<RemoteAppExecutionRepository> logger,
+            IOptions<InformaticsGatewayConfiguration> options,
+            IOptions<MongoDBOptions> mongoDbOptions)
+        {
+            Guard.Against.Null(serviceScopeFactory, nameof(serviceScopeFactory));
+            Guard.Against.Null(options, nameof(options));
+            Guard.Against.Null(mongoDbOptions, nameof(mongoDbOptions));
+
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+
+            _scope = serviceScopeFactory.CreateScope();
+            _retryPolicy = Policy.Handle<Exception>().WaitAndRetryAsync(
+                options.Value.Database.Retries.RetryDelays,
+                (exception, timespan, count, context) => _logger.DatabaseErrorRetry(timespan, count, exception));
+
+            var mongoDbClient = _scope.ServiceProvider.GetRequiredService<IMongoClient>();
+            var mongoDatabase = mongoDbClient.GetDatabase(mongoDbOptions.Value.DaatabaseName);
+            _collection = mongoDatabase.GetCollection<RemoteAppExecution>(nameof(RemoteAppExecution));
+            CreateIndexes();
+        }
+
+        private void CreateIndexes()
+        {
+            var options = new CreateIndexOptions { Unique = true, ExpireAfter = TimeSpan.FromDays(7), Name = "RequestTime" };
+            var indexDefinitionState = Builders<RemoteAppExecution>.IndexKeys.Ascending(_ => _.OutgoingStudyUid);
+            var indexModel = new CreateIndexModel<RemoteAppExecution>(indexDefinitionState, options);
+
+            _collection.Indexes.CreateOne(indexModel);
+        }
+
+        public async Task<bool> AddAsync(RemoteAppExecution item, CancellationToken cancellationToken = default)
+        {
+            Guard.Against.Null(item, nameof(item));
+
+            return await _retryPolicy.ExecuteAsync(async () =>
+            {
+                await _collection.InsertOneAsync(item, cancellationToken: cancellationToken).ConfigureAwait(false);
+                return true;
+            }).ConfigureAwait(false);
+        }
+
+        public async Task<int> RemoveAsync(string OutgoingStudyUid, CancellationToken cancellationToken = default)
+        {
+            return await _retryPolicy.ExecuteAsync(async () =>
+            {
+                var results = await _collection.DeleteManyAsync(Builders<RemoteAppExecution>.Filter.Where(p => p.OutgoingStudyUid == OutgoingStudyUid), cancellationToken).ConfigureAwait(false);
+                return Convert.ToInt32(results.DeletedCount);
+            }).ConfigureAwait(false);
+        }
+
+        public async Task<RemoteAppExecution?> GetAsync(string OutgoingStudyUid, CancellationToken cancellationToken = default)
+        {
+            return await _retryPolicy.ExecuteAsync(async () =>
+            {
+                return await _collection.Find(p => p.OutgoingStudyUid == OutgoingStudyUid).FirstOrDefaultAsync().ConfigureAwait(false);
+            }).ConfigureAwait(false);
+        }
+
+
+        public void Dispose(bool disposing)
+        {
+            if (!_disposedValue)
+            {
+                if (disposing)
+                {
+                    _scope.Dispose();
+                }
+
+                _disposedValue = true;
+            }
+        }
+        public void Dispose()
+        {
+            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
+
+    }
+}
diff --git a/src/InformaticsGateway/ExecutionPlugins/ExternalAppIncoming.cs b/src/InformaticsGateway/ExecutionPlugins/ExternalAppIncoming.cs
new file mode 100755
index 000000000..f202a1aac
--- /dev/null
+++ b/src/InformaticsGateway/ExecutionPlugins/ExternalAppIncoming.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Threading.Tasks;
+using FellowOakDicom;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Monai.Deploy.InformaticsGateway.Api;
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
+
+namespace Monai.Deploy.InformaticsGateway.ExecutionPlugins
+{
+    public class ExternalAppIncoming : IInputDataPlugin
+    {
+        private readonly ILogger<ExternalAppIncoming> _logger;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
+
+        public ExternalAppIncoming(
+            ILogger<ExternalAppIncoming> logger,
+            IServiceScopeFactory serviceScopeFactory)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
+        }
+
+        public async Task<(DicomFile dicomFile, FileStorageMetadata fileMetadata)> Execute(DicomFile dicomFile, FileStorageMetadata fileMetadata)
+        {
+            var scope = _serviceScopeFactory.CreateScope();
+            var repository = scope.ServiceProvider.GetRequiredService<IRemoteAppExecutionRepository>();
+
+            var incommingStudyUid = dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID);
+            var remoteAppExecution = await repository.GetAsync(incommingStudyUid);
+            if (remoteAppExecution is null)
+            {
+                _logger.LogOriginalStudyUidNotFound(incommingStudyUid);
+                return (dicomFile, fileMetadata);
+            }
+            foreach (var key in remoteAppExecution.OriginalValues.Keys)
+            {
+                dicomFile.Dataset.AddOrUpdate(key, remoteAppExecution.OriginalValues[key]);
+            }
+            dicomFile.Dataset.AddOrUpdate(DicomTag.StudyInstanceUID, remoteAppExecution.StudyUid);
+            fileMetadata.WorkflowInstanceId = remoteAppExecution.WorkflowInstanceId;
+            fileMetadata.TaskId = remoteAppExecution.ExportTaskId;
+
+            return (dicomFile, fileMetadata);
+        }
+    }
+}
diff --git a/src/InformaticsGateway/ExecutionPlugins/ExternalAppOutgoing.cs b/src/InformaticsGateway/ExecutionPlugins/ExternalAppOutgoing.cs
new file mode 100755
index 000000000..bef3d57b5
--- /dev/null
+++ b/src/InformaticsGateway/ExecutionPlugins/ExternalAppOutgoing.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using FellowOakDicom;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Monai.Deploy.InformaticsGateway.Api;
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Configuration;
+using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
+
+namespace Monai.Deploy.InformaticsGateway.ExecutionPlugins
+{
+    public class ExternalAppOutgoing : IOutputDataPlugin
+    {
+        private readonly ILogger<ExternalAppOutgoing> _logger;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
+
+        public ExternalAppOutgoing(
+            ILogger<ExternalAppOutgoing> logger,
+            IServiceScopeFactory serviceScopeFactory)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
+        }
+
+        public async Task<(DicomFile dicomFile, ExportRequestDataMessage exportRequestDataMessage)> Execute(DicomFile dicomFile, ExportRequestDataMessage exportRequestDataMessage)
+        {
+            //these are the standard tags, but this needs moving into config.
+            DicomTag[] tags = { DicomTag.StudyInstanceUID, DicomTag.AccessionNumber, DicomTag.SeriesInstanceUID, DicomTag.SOPInstanceUID };
+
+            var scope = _serviceScopeFactory.CreateScope();
+            var repository = scope.ServiceProvider.GetRequiredService<IRemoteAppExecutionRepository>();
+
+            var remoteAppExecution = await GetRemoteAppExecution(exportRequestDataMessage, tags).ConfigureAwait(false);
+            remoteAppExecution.StudyUid = dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID);
+
+            await repository.AddAsync(remoteAppExecution).ConfigureAwait(false);
+            _logger.LogStudyUidChanged(remoteAppExecution.StudyUid, remoteAppExecution.OutgoingStudyUid);
+
+            foreach (var tag in tags)
+            {
+                if (tag.Equals(DicomTag.StudyInstanceUID) is false)
+                {
+                    remoteAppExecution.OriginalValues.Add(tag, dicomFile.Dataset.GetString(tag));
+                    dicomFile.Dataset.AddOrUpdate(tag, DicomUIDGenerator.GenerateDerivedFromUUID());
+                }
+            }
+
+            dicomFile.Dataset.AddOrUpdate(DicomTag.StudyInstanceUID, remoteAppExecution.OutgoingStudyUid);
+
+            return (dicomFile, exportRequestDataMessage);
+        }
+
+        private async Task<RemoteAppExecution> GetRemoteAppExecution(ExportRequestDataMessage request, DicomTag[] tags)
+        {
+            var remoteAppExecution = new RemoteAppExecution
+            {
+                CorrelationId = request.CorrelationId,
+                WorkflowInstanceId = request.WorkflowInstanceId,
+                ExportTaskId = request.ExportTaskId,
+                Files = new System.Collections.Generic.List<string> { request.Filename },
+                Status = request.ExportStatus
+            };
+
+
+            var outgoingStudyUid = DicomUIDGenerator.GenerateDerivedFromUUID().UID;
+            remoteAppExecution.OutgoingStudyUid = outgoingStudyUid;
+
+
+            foreach (var destination in request.Destinations)
+            {
+                remoteAppExecution.ExportDetails.Add(await LookupDestinationAsync(destination, new CancellationToken()));
+            }
+
+            return remoteAppExecution;
+        }
+
+        private async Task<DestinationApplicationEntity> LookupDestinationAsync(string destinationName, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(destinationName))
+            {
+                throw new ConfigurationException("Export task does not have destination set.");
+            }
+
+            using var scope = _serviceScopeFactory.CreateScope();
+            var repository = scope.ServiceProvider.GetRequiredService<IDestinationApplicationEntityRepository>();
+            var destination = await repository.FindByNameAsync(destinationName, cancellationToken).ConfigureAwait(false);
+
+            if (destination is null)
+            {
+                throw new ConfigurationException($"Specified destination '{destinationName}' does not exist.");
+            }
+
+            return destination;
+        }
+    }
+}
diff --git a/src/InformaticsGateway/ExecutionPlugins/Log.1000.cs b/src/InformaticsGateway/ExecutionPlugins/Log.1000.cs
new file mode 100755
index 000000000..b9174d653
--- /dev/null
+++ b/src/InformaticsGateway/ExecutionPlugins/Log.1000.cs
@@ -0,0 +1,13 @@
+using Microsoft.Extensions.Logging;
+
+namespace Monai.Deploy.InformaticsGateway.ExecutionPlugins
+{
+    public static partial class Log
+    {
+        [LoggerMessage(EventId = 1000, Level = LogLevel.Debug, Message = "Changed the StudyUid from {OriginalStudyUid} to {NewStudyUid}")]
+        public static partial void LogStudyUidChanged(this ILogger logger, string OriginalStudyUid, string NewStudyUid);
+
+        [LoggerMessage(EventId = 1001, Level = LogLevel.Error, Message = "Cannot find entry for OriginalStudyUid {OriginalStudyUid} ")]
+        public static partial void LogOriginalStudyUidNotFound(this ILogger logger, string OriginalStudyUid);
+    }
+}
diff --git a/src/InformaticsGateway/Monai - Backup.Deploy.InformaticsGateway.csproj b/src/InformaticsGateway/Monai - Backup.Deploy.InformaticsGateway.csproj
new file mode 100644
index 000000000..60a16cbd8
--- /dev/null
+++ b/src/InformaticsGateway/Monai - Backup.Deploy.InformaticsGateway.csproj	
@@ -0,0 +1,114 @@
+<!--
+  ~ Copyright 2022 MONAI Consortium
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~ http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>Monai.Deploy.InformaticsGateway</RootNamespace>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
+    <IncludePackageReferencesDuringMarkupCompilation>true</IncludePackageReferencesDuringMarkupCompilation>
+    <EnforceCodeStyleInBuild>True</EnforceCodeStyleInBuild>
+    <LangVersion>latest</LangVersion>
+    <CodeAnalysisRuleSet>..\.sonarlint\project-monai_monai-deploy-informatics-gatewaycsharp.ruleset</CodeAnalysisRuleSet>
+    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+    <UserSecretsId>be0fffc8-bebb-4509-a2c0-3c981e5415ab</UserSecretsId>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Ardalis.GuardClauses" Version="4.1.1" />
+    <PackageReference Include="DotNext.Threading" Version="4.7.4" />
+    <PackageReference Include="fo-dicom" Version="5.1.1" />
+    <PackageReference Include="Karambolo.Extensions.Logging.File" Version="3.4.0" />
+    <PackageReference Include="HL7-dotnetcore" Version="2.35.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="6.0.20" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.Abstractions" Version="6.0.20" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="6.0.20" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
+    <PackageReference Include="Monai.Deploy.Messaging.RabbitMQ" Version="0.1.24" />
+    <PackageReference Include="Monai.Deploy.Security" Version="0.1.3" />
+    <PackageReference Include="Monai.Deploy.Storage" Version="0.2.16" />
+    <PackageReference Include="Monai.Deploy.Storage.MinIO" Version="0.2.16" />
+    <PackageReference Include="NLog.Web.AspNetCore" Version="5.3.2" />
+    <PackageReference Include="NLog" Version="5.2.2" />
+    <PackageReference Include="Polly" Version="7.2.4" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>$(AssemblyName).Test</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Remove="Test\**" />
+    <EmbeddedResource Remove="Test\**" />
+    <None Remove="Test\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <AdditionalFiles Include="..\.sonarlint\project-monai_monai-deploy-informatics-gateway\CSharp\SonarLint.xml" Link="SonarLint.xml" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="..\AssemblyInfo.cs" Link="AssemblyInfo.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Api\Monai.Deploy.InformaticsGateway.Api.csproj" />
+    <ProjectReference Include="..\Common\Monai.Deploy.InformaticsGateway.Common.csproj" />
+    <ProjectReference Include="..\Configuration\Monai.Deploy.InformaticsGateway.Configuration.csproj" />
+    <ProjectReference Include="..\Database\Api\Monai.Deploy.InformaticsGateway.Database.Api.csproj" />
+    <ProjectReference Include="..\Database\EntityFramework\Monai.Deploy.InformaticsGateway.Database.EntityFramework.csproj" />
+    <ProjectReference Include="..\Database\Monai.Deploy.InformaticsGateway.Database.csproj" />
+    <ProjectReference Include="..\DicomWebClient\Monai.Deploy.InformaticsGateway.DicomWeb.Client.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="./appsettings.json" CopyToOutputDirectory="Always" />
+    <None Include="./appsettings.Development.json" CopyToOutputDirectory="Always" />
+    <None Include="./nlog.config" CopyToOutputDirectory="Always" />
+  </ItemGroup>
+
+  <Target Name="CopyPlugins" AfterTargets="Publish">
+    <ItemGroup>
+      <PluginDlls Include="$(PublishDir)Monai.Deploy.Messaging.RabbitMQ.dll;$(PublishDir)Monai.Deploy.Storage.MinIO.dll;$(PublishDir)Minio.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(PluginDlls)" DestinationFolder="$(PublishDir)\plug-ins\" SkipUnchangedFiles="true" />
+    <Message Text="Files copied successfully to $(PublishDir)\plug-ins\." Importance="high" />
+  </Target>
+
+  <Target Name="CopyPluginsBuild" AfterTargets="Build">
+    <ItemGroup>
+      <PluginDlls Include="$(OutDir)Monai.Deploy.Messaging.RabbitMQ.dll;$(OutDir)Monai.Deploy.Storage.MinIO.dll;$(OutDir)Minio.dll" />
+    </ItemGroup>
+    <Copy SourceFiles="@(PluginDlls)" DestinationFolder="$(OutDir)\plug-ins\" SkipUnchangedFiles="true" />
+    <Message Text="Files copied successfully to $(OutDir)\plug-ins\." Importance="high" />
+  </Target>
+
+  <ProjectExtensions><VisualStudio><UserProperties appsettings_1json__JsonSchema="https://json.schemastore.org/band-manifest.json" /></VisualStudio></ProjectExtensions>
+</Project>
diff --git a/src/InformaticsGateway/Monai.Deploy.InformaticsGateway.csproj b/src/InformaticsGateway/Monai.Deploy.InformaticsGateway.csproj
old mode 100644
new mode 100755
diff --git a/src/InformaticsGateway/Program.cs b/src/InformaticsGateway/Program.cs
old mode 100644
new mode 100755
diff --git a/src/InformaticsGateway/Test/Services/Common/ExternalAppPluginTest.cs b/src/InformaticsGateway/Test/Services/Common/ExternalAppPluginTest.cs
new file mode 100755
index 000000000..2c9f00cd4
--- /dev/null
+++ b/src/InformaticsGateway/Test/Services/Common/ExternalAppPluginTest.cs
@@ -0,0 +1,237 @@
+using System;
+using System.Collections.Generic;
+using FellowOakDicom;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Monai.Deploy.InformaticsGateway.Common;
+using Monai.Deploy.InformaticsGateway.ExecutionPlugins;
+using Monai.Deploy.InformaticsGateway.Services.Common;
+using Moq;
+using Xunit;
+using System.Threading.Tasks;
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Api;
+using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
+using System.Threading;
+
+namespace Monai.Deploy.InformaticsGateway.Test.Services.Common
+{
+    public class ExternalAppPluginTest
+    {
+        private readonly Mock<ILogger<ExternalAppIncoming>> _logger;
+        private readonly Mock<ILogger<ExternalAppOutgoing>> _loggerOut;
+        private readonly Mock<IServiceScopeFactory> _serviceScopeFactory;
+        private readonly Mock<IServiceScope> _serviceScope;
+        private readonly Mock<IRemoteAppExecutionRepository> _repository;
+        private readonly Mock<IDestinationApplicationEntityRepository> _destRepo;
+        private readonly ServiceProvider _serviceProvider;
+
+        public ExternalAppPluginTest()
+        {
+            _logger = new Mock<ILogger<ExternalAppIncoming>>();
+            _loggerOut = new Mock<ILogger<ExternalAppOutgoing>>();
+            _serviceScopeFactory = new Mock<IServiceScopeFactory>();
+            _serviceScope = new Mock<IServiceScope>();
+            _repository = new Mock<IRemoteAppExecutionRepository>();
+            _destRepo = new Mock<IDestinationApplicationEntityRepository>();
+            _destRepo.Setup(d => d.FindByNameAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(new DestinationApplicationEntity()));
+
+            var services = new ServiceCollection();
+            services.AddScoped(p => _logger.Object);
+            services.AddScoped(p => _loggerOut.Object);
+            services.AddScoped(p => _repository.Object);
+            services.AddScoped(p => _destRepo.Object);
+
+            _serviceProvider = services.BuildServiceProvider();
+
+            _serviceScopeFactory.Setup(p => p.CreateScope()).Returns(_serviceScope.Object);
+            _serviceScope.Setup(p => p.ServiceProvider).Returns(_serviceProvider);
+
+            _logger.Setup(p => p.IsEnabled(It.IsAny<LogLevel>())).Returns(true);
+        }
+
+        [Fact]
+        public void GivenAnExternalAppIncoming_WhenInitialized_ExpectParametersToBeValidated()
+        {
+            Assert.Throws<ArgumentNullException>(() => new ExternalAppIncoming(null, null));
+            Assert.Throws<ArgumentNullException>(() => new ExternalAppIncoming(null, _serviceScopeFactory.Object));
+
+            _ = new ExternalAppIncoming(_logger.Object, _serviceScopeFactory.Object);
+        }
+
+        [Fact]
+        public void GivenAnExternalAppOutgoing_WhenInitialized_ExpectParametersToBeValidated()
+        {
+            Assert.Throws<ArgumentNullException>(() => new ExternalAppOutgoing(null, null));
+            Assert.Throws<ArgumentNullException>(() => new ExternalAppOutgoing(null, _serviceScopeFactory.Object));
+
+            _ = new ExternalAppOutgoing(_loggerOut.Object, _serviceScopeFactory.Object);
+        }
+
+        [Fact]
+        public void GivenAnOutputDataPluginEngine_WhenConfigureIsCalledWithAValidAssembly_ExpectNoExceptions()
+        {
+            var pluginEngine = new OutputDataPluginEngine(
+                _serviceProvider,
+                new Mock<ILogger<OutputDataPluginEngine>>().Object,
+                new Mock<IDicomToolkit>().Object);
+
+            var assemblies = new List<string>() {
+                typeof(ExternalAppOutgoing).AssemblyQualifiedName};
+
+            pluginEngine.Configure(assemblies);
+        }
+
+        [Fact]
+        public void GivenAnInputDataPluginEngine_WhenConfigureIsCalledWithAValidAssembly_ExpectNoExceptions()
+        {
+            var pluginEngine = new InputDataPluginEngine(
+                _serviceProvider,
+                new Mock<ILogger<InputDataPluginEngine>>().Object);
+
+            var assemblies = new List<string>() {
+                typeof(ExternalAppIncoming).AssemblyQualifiedName};
+
+            pluginEngine.Configure(assemblies);
+        }
+
+        [Fact]
+        public async Task ExternalAppPlugin_Should_Replace_StudyUid_Plus_SaveData()
+        {
+            var toolkit = new Mock<IDicomToolkit>();
+
+            RemoteAppExecution localCopy = new RemoteAppExecution();
+
+            _repository.Setup(r => r.AddAsync(It.IsAny<RemoteAppExecution>(), It.IsAny<CancellationToken>()))
+                .Callback((RemoteAppExecution item, CancellationToken c) => localCopy = item);
+            var dataset = new DicomDataset
+            {
+                { DicomTag.PatientID, "PID" },
+                { DicomTag.StudyInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SeriesInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage.UID }
+            };
+            var dicomFile = new DicomFile(dataset);
+            var dicomInfo = new DicomFileStorageMetadata(
+                Guid.NewGuid().ToString(),
+                Guid.NewGuid().ToString(),
+                dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID),
+                dicomFile.Dataset.GetString(DicomTag.SeriesInstanceUID),
+                dicomFile.Dataset.GetString(DicomTag.SOPInstanceUID));
+
+            var originalStudyUid = dataset.GetString(DicomTag.StudyInstanceUID);
+
+            toolkit.Setup(t => t.Load(It.IsAny<byte[]>())).Returns(dicomFile);
+
+            var pluginEngine = new OutputDataPluginEngine(
+                _serviceProvider,
+                new Mock<ILogger<OutputDataPluginEngine>>().Object,
+                toolkit.Object);
+            pluginEngine.Configure(new List<string>() { typeof(ExternalAppOutgoing).AssemblyQualifiedName });
+
+            string[] destinations = { "fred" };
+
+            var exportMessage = new ExportRequestDataMessage(new Messaging.Events.ExportRequestEvent() { Destinations = destinations }, "");
+
+            var exportRequestDataMessage = await pluginEngine.ExecutePlugins(exportMessage);
+
+            Assert.Equal(originalStudyUid, localCopy.StudyUid);
+            Assert.Equal(dataset.GetString(DicomTag.StudyInstanceUID), localCopy.OutgoingStudyUid);
+            Assert.NotEqual(originalStudyUid, dataset.GetString(DicomTag.StudyInstanceUID));
+        }
+
+
+        [Fact]
+        public async Task ExternalAppPlugin_Should_Repare_StudyUid()
+        {
+            var toolkit = new Mock<IDicomToolkit>();
+
+            var dataset = new DicomDataset
+            {
+                { DicomTag.PatientID, "PID" },
+                { DicomTag.StudyInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SeriesInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage.UID }
+            };
+            var dicomFile = new DicomFile(dataset);
+            var dicomInfo = new DicomFileStorageMetadata(
+                Guid.NewGuid().ToString(),
+                Guid.NewGuid().ToString(),
+                dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID),
+                dicomFile.Dataset.GetString(DicomTag.SeriesInstanceUID),
+                dicomFile.Dataset.GetString(DicomTag.SOPInstanceUID));
+
+            var outboundStudyUid = dataset.GetString(DicomTag.StudyInstanceUID);
+            var originalStudyUid = DicomUIDGenerator.GenerateDerivedFromUUID().UID;
+
+            var remoteAppExecution = new RemoteAppExecution
+            {
+                OutgoingStudyUid = outboundStudyUid,
+                StudyUid = originalStudyUid
+            };
+
+            _repository.Setup(r => r.GetAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(remoteAppExecution));
+
+            var pluginEngine = new InputDataPluginEngine(
+                _serviceProvider,
+                new Mock<ILogger<InputDataPluginEngine>>().Object);
+
+            pluginEngine.Configure(new List<string>() { typeof(ExternalAppIncoming).AssemblyQualifiedName });
+
+            var (resultDicomFile, resultDicomInfo) = await pluginEngine.ExecutePlugins(dicomFile, dicomInfo);
+
+            Assert.Equal(originalStudyUid, resultDicomFile.Dataset.GetString(DicomTag.StudyInstanceUID));
+            Assert.NotEqual(outboundStudyUid, resultDicomFile.Dataset.GetString(DicomTag.StudyInstanceUID));
+        }
+
+        [Fact]
+        public async Task ExternalAppPlugin_Should_Set_WorkflowIds()
+        {
+
+            var dataset = new DicomDataset
+            {
+                { DicomTag.PatientID, "PID" },
+                { DicomTag.StudyInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SeriesInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SOPInstanceUID, DicomUIDGenerator.GenerateDerivedFromUUID() },
+                { DicomTag.SOPClassUID, DicomUID.SecondaryCaptureImageStorage.UID }
+            };
+            var dicomFile = new DicomFile(dataset);
+            var dicomInfo = new DicomFileStorageMetadata(
+                Guid.NewGuid().ToString(),
+                Guid.NewGuid().ToString(),
+                dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID),
+                dicomFile.Dataset.GetString(DicomTag.SeriesInstanceUID),
+                dicomFile.Dataset.GetString(DicomTag.SOPInstanceUID));
+
+            var workflowInstanceId = "some guid here";
+            var workflowTaskId = "some guid here 2";
+
+            var remoteAppExecution = new RemoteAppExecution
+            {
+                OutgoingStudyUid = DicomUIDGenerator.GenerateDerivedFromUUID().UID,
+                StudyUid = DicomUIDGenerator.GenerateDerivedFromUUID().UID,
+                WorkflowInstanceId = workflowInstanceId,
+                ExportTaskId = workflowTaskId
+            };
+
+            _repository.Setup(r => r.GetAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(remoteAppExecution));
+
+            var pluginEngine = new InputDataPluginEngine(
+                _serviceProvider,
+                new Mock<ILogger<InputDataPluginEngine>>().Object);
+
+            pluginEngine.Configure(new List<string>() { typeof(ExternalAppIncoming).AssemblyQualifiedName });
+
+            var (resultDicomFile, resultDicomInfo) = await pluginEngine.ExecutePlugins(dicomFile, dicomInfo);
+            Assert.Equal(workflowInstanceId, resultDicomInfo.WorkflowInstanceId);
+            Assert.Equal(workflowTaskId, resultDicomInfo.TaskId);
+        }
+
+    }
+}
diff --git a/src/InformaticsGateway/Test/packages.lock.json b/src/InformaticsGateway/Test/packages.lock.json
old mode 100644
new mode 100755
diff --git a/src/InformaticsGateway/packages.lock.json b/src/InformaticsGateway/packages.lock.json
old mode 100644
new mode 100755
diff --git a/tests/Integration.Test/packages.lock.json b/tests/Integration.Test/packages.lock.json
old mode 100644
new mode 100755