diff --git a/src/ServiceControl.Config.Tests/InstanceDetails/CorruptInstanceConfiguration.cs b/src/ServiceControl.Config.Tests/InstanceDetails/CorruptInstanceConfiguration.cs
new file mode 100644
index 0000000000..5245eac65a
--- /dev/null
+++ b/src/ServiceControl.Config.Tests/InstanceDetails/CorruptInstanceConfiguration.cs
@@ -0,0 +1,434 @@
+namespace ServiceControl.Config.Tests.InstanceDetails
+{
+    using System;
+    using System.IO;
+    using System.ServiceProcess;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Caliburn.Micro;
+    using NUnit.Framework;
+    using ServiceControl.Config.Events;
+    using ServiceControl.Config.UI.InstanceDetails;
+    using ServiceControl.Config.UI.ListInstances;
+    using ServiceControlInstaller.Engine.Instances;
+    using ServiceControlInstaller.Engine.Services;
+
+    /// <summary>
+    /// Executable specification for SCMU resilience to corrupt instance configuration files
+    /// (bug https://github.com/Particular/ServiceControl/issues/2759).
+    ///
+    /// Organized as feature > rule > examples:
+    /// - this outer class is the feature,
+    /// - each nested fixture is one rule,
+    /// - each test is one example, named with "The one where ..." language.
+    ///
+    /// The tests load real ServiceControl / ServiceControl.Audit instances from real
+    /// (corrupt or valid) configuration files written to a temp install folder, substituting
+    /// the Windows service through the existing IWindowsServiceController seam, and observe
+    /// the same InstanceDetailsViewModel state the UI binds to.
+    /// </summary>
+    public class CorruptInstanceConfiguration
+    {
+        [TestFixture]
+        public class Rule_1_Must_load_every_instance_even_when_its_configuration_file_is_corrupt : CorruptInstanceConfigurationFixture
+        {
+            [Test]
+            public void The_one_where_the_error_instance_config_xml_is_corrupt_and_the_instance_still_loads_flagged_with_the_error()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+
+                var instance = LoadErrorInstance();
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(instance.ConfigurationLoadError, Is.Not.Null.And.Not.Empty,
+                        "A corrupt config must be reported as a configuration load error");
+                    Assert.That(instance.InstanceName, Is.EqualTo(ServiceName),
+                        "The instance name must fall back to the Windows service name when the config cannot be read");
+                    Assert.That(instance.ReportCard.Errors, Is.Not.Empty);
+                }
+            }
+
+            [Test]
+            public void The_one_where_the_audit_instance_config_xml_is_corrupt_and_the_instance_still_loads_flagged_with_the_error()
+            {
+                WriteAuditInstanceConfig(CorruptXml);
+
+                var instance = LoadAuditInstance();
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(instance.ConfigurationLoadError, Is.Not.Null.And.Not.Empty,
+                        "A corrupt config must be reported as a configuration load error");
+                    Assert.That(instance.InstanceName, Is.EqualTo(ServiceName),
+                        "The instance name must fall back to the Windows service name when the config cannot be read");
+                    Assert.That(instance.ReportCard.Errors, Is.Not.Empty);
+                }
+            }
+
+            [Test]
+            public void The_one_where_the_monitoring_instance_config_xml_is_corrupt_and_the_instance_still_loads_flagged_with_the_error()
+            {
+                WriteMonitoringInstanceConfig(CorruptXml);
+
+                var instance = LoadMonitoringInstance();
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(instance.ConfigurationLoadError, Is.Not.Null.And.Not.Empty,
+                        "A corrupt config must be reported as a configuration load error");
+                    Assert.That(instance.InstanceName, Is.EqualTo(ServiceName),
+                        "The instance name must fall back to the Windows service name when the config cannot be read");
+                    Assert.That(instance.ReportCard.Errors, Is.Not.Empty);
+                }
+            }
+
+            [Test]
+            public void The_one_where_the_configuration_is_valid_and_no_error_is_flagged()
+            {
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+
+                var instance = LoadErrorInstance();
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(instance.ConfigurationLoadError, Is.Null.Or.Empty);
+                    Assert.That(instance.TransportPackage, Is.Not.Null,
+                        "A valid config must load fully, including the transport");
+                }
+            }
+        }
+
+        [TestFixture]
+        public class Rule_2_Must_show_the_configuration_error_in_place_of_the_service_status : CorruptInstanceConfigurationFixture
+        {
+            [Test]
+            public void The_one_where_the_status_reads_configuration_error_and_no_running_or_stopped_indicator_is_shown()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.HasConfigurationError, Is.True);
+                    Assert.That(viewModel.Status, Is.EqualTo("ERROR"));
+                    Assert.That(viewModel.IsRunning, Is.False, "No running indicator for a corrupt instance");
+                    Assert.That(viewModel.IsStopped, Is.False, "No stopped indicator for a corrupt instance");
+                }
+            }
+
+            [Test]
+            public void The_one_where_the_error_banner_explains_that_the_configuration_failed_to_load_and_names_the_file()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+
+                var instance = LoadErrorInstance();
+                var viewModel = DetailsFor(instance);
+
+                Assert.That(viewModel.ConfigurationErrorMessage,
+                    Does.Contain("Failed to load configuration file").And.Contain(instance.ConfigurationFilePath),
+                    "The banner must point the operator at the file that needs fixing");
+            }
+
+            [Test]
+            public void The_one_where_the_configuration_is_valid_and_the_windows_service_status_is_shown_as_usual()
+            {
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.HasConfigurationError, Is.False);
+                    Assert.That(viewModel.Status, Is.EqualTo("STOPPED"));
+                    Assert.That(viewModel.IsStopped, Is.True);
+                }
+            }
+        }
+
+        [TestFixture]
+        public class Rule_3_Must_block_actions_that_require_a_valid_configuration_while_the_error_persists : CorruptInstanceConfigurationFixture
+        {
+            [Test]
+            public void The_one_where_start_and_stop_are_not_allowed()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.AllowStart, Is.False);
+                    Assert.That(viewModel.AllowStop, Is.False);
+                }
+            }
+
+            [Test]
+            public void The_one_where_edit_and_advanced_options_are_hidden()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                Assert.That(viewModel.AllowEdit, Is.False);
+            }
+
+            [Test]
+            public void The_one_where_no_transport_or_persister_is_reported()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.Transport, Is.Null);
+                    Assert.That(viewModel.Persister, Is.Empty);
+                }
+            }
+
+            [Test]
+            public void The_one_where_the_configuration_is_valid_and_the_instance_can_be_edited_and_started_as_usual()
+            {
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.AllowEdit, Is.True);
+                    Assert.That(viewModel.AllowStart, Is.True, "A stopped, healthy instance can be started");
+                }
+            }
+        }
+
+        [TestFixture]
+        public class Rule_4_Should_recover_the_instance_once_the_configuration_file_is_fixed_and_the_list_is_refreshed : CorruptInstanceConfigurationFixture
+        {
+            [Test]
+            public void The_one_where_the_config_file_is_fixed_on_disk_and_refresh_returns_the_instance_to_normal()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+                var viewModel = DetailsFor(LoadErrorInstance());
+                Assert.That(viewModel.HasConfigurationError, Is.True, "Precondition: the instance starts out corrupt");
+
+                // The operator fixes the file, then SCMU refreshes and re-reads instances from disk
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+                viewModel.UpdateServiceInstance(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.HasConfigurationError, Is.False);
+                    Assert.That(viewModel.Status, Is.EqualTo("STOPPED"));
+                    Assert.That(viewModel.AllowEdit, Is.True);
+                }
+            }
+
+            [Test]
+            public async Task The_one_where_the_config_file_becomes_corrupt_after_loading_and_the_next_refresh_flags_the_error()
+            {
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+                var instance = LoadErrorInstance();
+                var viewModel = DetailsFor(instance);
+                Assert.That(viewModel.HasConfigurationError, Is.False, "Precondition: the instance starts out healthy");
+
+                // The file is corrupted while SCMU is running, then a refresh reloads it
+                WriteErrorInstanceConfig(CorruptXml);
+                await viewModel.HandleAsync(new PostRefreshInstances(), CancellationToken.None);
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(viewModel.HasConfigurationError, Is.True);
+                    Assert.That(viewModel.Status, Is.EqualTo("ERROR"));
+                    Assert.That(viewModel.ConfigurationErrorMessage, Does.Contain(instance.ConfigurationFilePath));
+                }
+            }
+
+            [Test]
+            public async Task The_one_where_the_fix_is_picked_up_through_the_deployed_instances_refresh_flow()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+                var list = new ListInstancesViewModel(DetailsFor, () => [LoadErrorInstance()])
+                {
+                    EventAggregator = new EventAggregator()
+                };
+                Assert.That(list.HasConfigurationErrors, Is.True, "Precondition: the list starts out with a corrupt instance");
+
+                // The operator fixes the file, then triggers the refresh the UI uses
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+                await list.HandleAsync(new RefreshInstances(), CancellationToken.None);
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(list.HasConfigurationErrors, Is.False);
+                    Assert.That(list.ConfigurationErrorMessage, Is.Null);
+                }
+            }
+
+            [Test]
+            public void The_one_where_a_refresh_tries_to_apply_data_from_a_differently_named_instance_and_is_rejected()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                var differentInstance = LoadErrorInstance(serviceName: "Particular.ServiceControl.Other");
+
+                Assert.That(() => viewModel.UpdateServiceInstance(differentInstance), Throws.ArgumentException);
+            }
+
+            [Test]
+            public void The_one_where_a_refresh_tries_to_apply_data_from_an_instance_of_a_different_type_and_is_rejected()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+                var viewModel = DetailsFor(LoadErrorInstance());
+
+                WriteAuditInstanceConfig(CorruptXml);
+                var differentTypeInstance = LoadAuditInstance(); // same service name, different instance type
+
+                Assert.That(() => viewModel.UpdateServiceInstance(differentTypeInstance), Throws.ArgumentException);
+            }
+        }
+
+        [TestFixture]
+        public class Rule_5_Must_summarize_configuration_errors_above_the_instance_list : CorruptInstanceConfigurationFixture
+        {
+            [Test]
+            public void The_one_where_a_single_instance_is_corrupt_and_the_banner_names_it()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+                WriteAuditInstanceConfig(ValidAuditInstanceXml);
+
+                var list = ListFor(LoadErrorInstance(), LoadAuditInstance("Particular.ServiceControl.Audit"));
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(list.HasConfigurationErrors, Is.True);
+                    Assert.That(list.ConfigurationErrorMessage,
+                        Is.EqualTo("Particular.ServiceControl instance cannot be loaded due to XML configuration error."));
+                }
+            }
+
+            [Test]
+            public void The_one_where_multiple_instances_are_corrupt_and_the_banner_lists_all_of_them()
+            {
+                WriteErrorInstanceConfig(CorruptXml);
+                WriteAuditInstanceConfig(CorruptXml);
+
+                var list = ListFor(LoadErrorInstance(), LoadAuditInstance("Particular.ServiceControl.Audit"));
+
+                Assert.That(list.ConfigurationErrorMessage,
+                    Is.EqualTo("Multiple instances (Particular.ServiceControl, Particular.ServiceControl.Audit) cannot be loaded due to XML configuration errors."));
+            }
+
+            [Test]
+            public void The_one_where_all_configurations_are_valid_and_no_banner_is_shown()
+            {
+                WriteErrorInstanceConfig(ValidErrorInstanceXml);
+
+                var list = ListFor(LoadErrorInstance());
+
+                using (Assert.EnterMultipleScope())
+                {
+                    Assert.That(list.HasConfigurationErrors, Is.False);
+                    Assert.That(list.ConfigurationErrorMessage, Is.Null);
+                }
+            }
+        }
+    }
+
+    public abstract class CorruptInstanceConfigurationFixture
+    {
+        protected const string ServiceName = "Particular.ServiceControl";
+
+        // A realistically corrupted file: truncated mid-element, as left behind by a failed edit
+        protected const string CorruptXml = """
+            <?xml version="1.0" encoding="utf-8"?>
+            <configuration>
+              <appSettings>
+                <add key="ServiceControl/TransportType" value="LearningTransport"
+            """;
+
+        protected const string ValidErrorInstanceXml = """
+            <?xml version="1.0" encoding="utf-8"?>
+            <configuration>
+              <appSettings>
+                <add key="ServiceControl/TransportType" value="LearningTransport" />
+              </appSettings>
+            </configuration>
+            """;
+
+        protected const string ValidAuditInstanceXml = """
+            <?xml version="1.0" encoding="utf-8"?>
+            <configuration>
+              <appSettings>
+                <add key="ServiceControl.Audit/TransportType" value="LearningTransport" />
+              </appSettings>
+            </configuration>
+            """;
+
+        protected string InstallPath { get; private set; }
+
+        [SetUp]
+        public void CreateInstallPath()
+        {
+            InstallPath = Path.Combine(Path.GetTempPath(), "SCMUCorruptConfigSpec", Path.GetRandomFileName());
+            Directory.CreateDirectory(InstallPath);
+        }
+
+        [TearDown]
+        public void DeleteInstallPath() => Directory.Delete(InstallPath, recursive: true);
+
+        protected void WriteErrorInstanceConfig(string contents) =>
+            File.WriteAllText(Path.Combine(InstallPath, $"{Constants.ServiceControlExe}.config"), contents);
+
+        protected void WriteAuditInstanceConfig(string contents) =>
+            File.WriteAllText(Path.Combine(InstallPath, $"{Constants.ServiceControlAuditExe}.config"), contents);
+
+        protected void WriteMonitoringInstanceConfig(string contents) =>
+            File.WriteAllText(Path.Combine(InstallPath, $"{Constants.MonitoringExe}.config"), contents);
+
+        protected ServiceControlInstance LoadErrorInstance(string serviceName = ServiceName) =>
+            new(new FakeWindowsServiceController(Path.Combine(InstallPath, Constants.ServiceControlExe), serviceName));
+
+        protected ServiceControlAuditInstance LoadAuditInstance(string serviceName = ServiceName) =>
+            new(new FakeWindowsServiceController(Path.Combine(InstallPath, Constants.ServiceControlAuditExe), serviceName));
+
+        protected MonitoringInstance LoadMonitoringInstance(string serviceName = ServiceName) =>
+            new(new FakeWindowsServiceController(Path.Combine(InstallPath, Constants.MonitoringExe), serviceName));
+
+        internal static InstanceDetailsViewModel DetailsFor(BaseService instance) =>
+            new(instance, null, null, null, null, null, null, null, null);
+
+        internal static ListInstancesViewModel ListFor(params BaseService[] instances) =>
+            new(DetailsFor, () => instances);
+
+        class FakeWindowsServiceController(string exePath, string serviceName) : IWindowsServiceController
+        {
+            public string ServiceName => serviceName;
+
+            public string ExePath => exePath;
+
+            public string Description { get; set; }
+
+            public ServiceControllerStatus Status => ServiceControllerStatus.Stopped;
+
+            public string Account => "LocalSystem";
+
+            public string DisplayName => serviceName;
+
+            public bool Exists() => true;
+
+            public void Refresh()
+            {
+            }
+
+            public void WaitForStatus(ServiceControllerStatus stopped, TimeSpan timeSpan) => throw new NotSupportedException();
+            public void Start() => throw new NotSupportedException();
+            public void Stop() => throw new NotSupportedException();
+            public void SetStartupMode(string v) => throw new NotSupportedException();
+            public void Delete() => throw new NotSupportedException();
+            public void ChangeAccountDetails(string accountName, string serviceAccountPwd) => throw new NotSupportedException();
+        }
+    }
+}
diff --git a/src/ServiceControl.Config/Commands/AdvancedMonitoringOptionsCommand.cs b/src/ServiceControl.Config/Commands/AdvancedMonitoringOptionsCommand.cs
index 00a163cb62..515b0b4d86 100644
--- a/src/ServiceControl.Config/Commands/AdvancedMonitoringOptionsCommand.cs
+++ b/src/ServiceControl.Config/Commands/AdvancedMonitoringOptionsCommand.cs
@@ -2,6 +2,8 @@ namespace ServiceControl.Config.Commands
 {
     using System;
     using System.Threading.Tasks;
+    using Caliburn.Micro;
+    using Events;
     using Framework;
     using Framework.Commands;
     using ServiceControlInstaller.Engine.Instances;
@@ -10,20 +12,22 @@ namespace ServiceControl.Config.Commands
 
     class AdvancedMonitoringOptionsCommand : AwaitableAbstractCommand<InstanceDetailsViewModel>
     {
-        public AdvancedMonitoringOptionsCommand(IServiceControlWindowManager windowManager, Func<BaseService, MonitoringAdvancedViewModel> advancedOptionsModel)
+        public AdvancedMonitoringOptionsCommand(IServiceControlWindowManager windowManager, IEventAggregator eventAggregator, Func<BaseService, MonitoringAdvancedViewModel> advancedOptionsModel)
         {
             this.windowManager = windowManager;
+            this.eventAggregator = eventAggregator;
             this.advancedOptionsModel = advancedOptionsModel;
         }
 
-        public override Task ExecuteAsync(InstanceDetailsViewModel viewModel)
+        public override async Task ExecuteAsync(InstanceDetailsViewModel viewModel)
         {
             var screen = advancedOptionsModel(viewModel.MonitoringInstance);
-
-            return windowManager.ShowInnerDialog(screen);
+            await windowManager.ShowInnerDialog(screen);
+            await eventAggregator.PublishOnUIThreadAsync(new RefreshInstances());
         }
 
         readonly Func<BaseService, MonitoringAdvancedViewModel> advancedOptionsModel;
+        readonly IEventAggregator eventAggregator;
         readonly IServiceControlWindowManager windowManager;
     }
 }
\ No newline at end of file
diff --git a/src/ServiceControl.Config/Commands/AdvancedServiceControlOptionsCommand.cs b/src/ServiceControl.Config/Commands/AdvancedServiceControlOptionsCommand.cs
index a5f4145d98..589613749d 100644
--- a/src/ServiceControl.Config/Commands/AdvancedServiceControlOptionsCommand.cs
+++ b/src/ServiceControl.Config/Commands/AdvancedServiceControlOptionsCommand.cs
@@ -2,6 +2,8 @@ namespace ServiceControl.Config.Commands
 {
     using System;
     using System.Threading.Tasks;
+    using Caliburn.Micro;
+    using Events;
     using Framework;
     using Framework.Commands;
     using ServiceControlInstaller.Engine.Instances;
@@ -10,16 +12,18 @@ namespace ServiceControl.Config.Commands
 
     class AdvancedServiceControlOptionsCommand : AwaitableAbstractCommand<InstanceDetailsViewModel>
     {
-        public AdvancedServiceControlOptionsCommand(IServiceControlWindowManager windowManager, Func<BaseService, ServiceControlAdvancedViewModel> advancedOptionsModel)
+        public AdvancedServiceControlOptionsCommand(IServiceControlWindowManager windowManager, IEventAggregator eventAggregator, Func<BaseService, ServiceControlAdvancedViewModel> advancedOptionsModel)
         {
             this.windowManager = windowManager;
+            this.eventAggregator = eventAggregator;
             this.advancedOptionsModel = advancedOptionsModel;
         }
 
-        public override Task ExecuteAsync(InstanceDetailsViewModel viewModel)
+        public override async Task ExecuteAsync(InstanceDetailsViewModel viewModel)
         {
             var screen = CreateAdvancedScreen(viewModel);
-            return windowManager.ShowInnerDialog(screen);
+            await windowManager.ShowInnerDialog(screen);
+            await eventAggregator.PublishOnUIThreadAsync(new RefreshInstances());
         }
 
         ServiceControlAdvancedViewModel CreateAdvancedScreen(InstanceDetailsViewModel viewModel)
@@ -34,6 +38,7 @@ ServiceControlAdvancedViewModel CreateAdvancedScreen(InstanceDetailsViewModel vi
         }
 
         readonly Func<BaseService, ServiceControlAdvancedViewModel> advancedOptionsModel;
+        readonly IEventAggregator eventAggregator;
         readonly IServiceControlWindowManager windowManager;
     }
 }
\ No newline at end of file
diff --git a/src/ServiceControl.Config/Styles/Icons.xaml b/src/ServiceControl.Config/Styles/Icons.xaml
index b4abe14306..a2fa4424da 100644
--- a/src/ServiceControl.Config/Styles/Icons.xaml
+++ b/src/ServiceControl.Config/Styles/Icons.xaml
@@ -101,6 +101,30 @@
         </Viewbox>
     </ControlTemplate>
 
+    <ControlTemplate x:Key="CopyIcon">
+        <Viewbox Stretch="Uniform">
+            <Canvas Width="16" Height="16">
+                <!-- back page -->
+                <Rectangle Canvas.Left="4" Canvas.Top="2" Width="9" Height="11"
+                           Fill="{TemplateBinding Foreground}" />
+                <Rectangle Canvas.Left="5" Canvas.Top="3" Width="7" Height="9"
+                           Fill="White" />
+                <!-- front page -->
+                <Rectangle Canvas.Left="2" Canvas.Top="4" Width="9" Height="11"
+                           Fill="{TemplateBinding Foreground}" />
+                <Rectangle Canvas.Left="3" Canvas.Top="5" Width="7" Height="9"
+                           Fill="White" />
+                <!-- lines on front page -->
+                <Rectangle Canvas.Left="4" Canvas.Top="7" Width="5" Height="1"
+                           Fill="{TemplateBinding Foreground}" />
+                <Rectangle Canvas.Left="4" Canvas.Top="9" Width="5" Height="1"
+                           Fill="{TemplateBinding Foreground}" />
+                <Rectangle Canvas.Left="4" Canvas.Top="11" Width="3" Height="1"
+                           Fill="{TemplateBinding Foreground}" />
+            </Canvas>
+        </Viewbox>
+    </ControlTemplate>
+
     <ControlTemplate x:Key="RemoveIcon">
         <Viewbox Stretch="Uniform">
             <Canvas Width="24" Height="24">
diff --git a/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsView.xaml b/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsView.xaml
index dcddb94c1a..477d4de761 100644
--- a/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsView.xaml
+++ b/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsView.xaml
@@ -58,13 +58,53 @@
                        Text="{Binding InstanceTypeDisplayName}" />
 
         </StackPanel>
+
+        <!-- Configuration Error Display -->
+        <StackPanel Grid.Row="3" Grid.ColumnSpan="2" Margin="0 0 0 10"
+                    Visibility="{Binding HasConfigurationError, Converter={StaticResource boolToVis}}">
+            <Border Background="#FFF4E5" BorderBrush="#FFA500" BorderThickness="1" Padding="10" CornerRadius="3">
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+                    <TextBlock Grid.Column="0" Text="⚠" FontSize="16" Foreground="#FFA500" VerticalAlignment="Top" Margin="0,0,8,0"/>
+                    <StackPanel Grid.Column="1">
+                        <TextBlock Text="CONFIGURATION ERROR" 
+                                   FontWeight="Bold" 
+                                   Foreground="#D84315" 
+                                   FontSize="13" 
+                                   Margin="0,0,0,5"/>
+                        <TextBlock Text="{Binding ConfigurationErrorMessage}" 
+                                   TextWrapping="Wrap" 
+                                   Foreground="#5D4037" 
+                                   FontSize="12"/>
+                    </StackPanel>
+                    <Button Grid.Column="2" Padding="0" Background="Transparent" BorderThickness="0"
+                            VerticalAlignment="Top" Margin="8,0,0,0"
+                            Command="{Binding CopyToClipboard}" CommandParameter="{Binding ConfigurationErrorMessage}"
+                            ToolTip="Copy error message" Cursor="Hand">
+                        <ContentControl Template="{StaticResource CopyIcon}" Foreground="#5D4037" Width="14" Height="14" />
+                    </Button>
+                </Grid>
+            </Border>
+        </StackPanel>
+
         <StackPanel Grid.Row="2" Grid.Column="1" Margin="0 0 0 10">
             <StackPanel Orientation="Horizontal">
+                <!-- Show warning icon for configuration errors -->
+                <TextBlock Margin="0,0,3,0"
+                    VerticalAlignment="Center"
+                    FontSize="16px"
+                    Foreground="#FFA500"
+                    Text="⚠"
+                    Visibility="{Binding HasConfigurationError, Converter={StaticResource boolToVis}}" />
+
                 <ContentControl Margin="0,0,0,0"
-                                VerticalAlignment="Center"
-                                Template="{StaticResource RunningIcon}"
-                                Visibility="{Binding IsRunning,
-                                                 Converter={StaticResource boolToVis}}" />
+                     VerticalAlignment="Center"
+                     Template="{StaticResource RunningIcon}"
+                     Visibility="{Binding IsRunning, Converter={StaticResource boolToVis}}" />
 
                 <ContentControl Margin="0,0,0,0"
                                 VerticalAlignment="Center"
@@ -75,8 +115,19 @@
                 <TextBlock Margin="3,0,0,0"
                            VerticalAlignment="Center"
                            FontSize="13px"
-                           Foreground="{StaticResource Gray40Brush}"
-                           Text="{Binding Status}" />
+                           Text="{Binding Status}">
+                    <TextBlock.Style>
+                        <Style TargetType="TextBlock">
+                            <Setter Property="Foreground" Value="{StaticResource Gray40Brush}" />
+                            <Style.Triggers>
+                                <DataTrigger Binding="{Binding HasConfigurationError}" Value="True">
+                                    <Setter Property="Foreground" Value="#D84315" />
+                                    <Setter Property="FontWeight" Value="Bold" />
+                                </DataTrigger>
+                            </Style.Triggers>
+                        </Style>
+                    </TextBlock.Style>
+                </TextBlock>
 
                 <TextBlock  Margin="3,0,0,0"
                             VerticalAlignment="Center"
@@ -107,12 +158,14 @@
                     Command="{Binding EditCommand}"
                     CommandParameter="{Binding DataContext,
                                                ElementName=root}"
-                    Style="{StaticResource ConfigurationButton}" />
+                    Style="{StaticResource ConfigurationButton}"
+                    Visibility="{Binding AllowEdit, Converter={StaticResource boolToVis}}" />
             <Button Margin="5,0"
                     Command="{Binding AdvancedOptionsCommand}"
                     CommandParameter="{Binding DataContext,
                                                ElementName=root}"
-                    Style="{StaticResource AdvancedOptionsButton}" />
+                    Style="{StaticResource AdvancedOptionsButton}"
+                    Visibility="{Binding AllowEdit, Converter={StaticResource boolToVis}}" />
         </StackPanel>
 
         <GroupBox Grid.Row="4" Header="VERSION" Margin="0 5 0 0">
diff --git a/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsViewModel.cs b/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsViewModel.cs
index 57ad612610..4a1c9dd14d 100644
--- a/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsViewModel.cs
+++ b/src/ServiceControl.Config/UI/InstanceDetails/InstanceDetailsViewModel.cs
@@ -34,8 +34,6 @@ public InstanceDetailsViewModel(
             StartCommand = Command.Create(() => StartService());
             StopCommand = Command.Create(() => StopService());
 
-            ServiceInstance = instance;
-
             if (instance.GetType() == typeof(ServiceControlInstance))
             {
                 ServiceControlInstance = (ServiceControlInstance)instance;
@@ -72,7 +70,37 @@ public InstanceDetailsViewModel(
             throw new Exception("Unknown instance type");
         }
 
-        public BaseService ServiceInstance { get; }
+        public void UpdateServiceInstance(BaseService updatedInstance)
+        {
+            if (updatedInstance.Name != ServiceInstance.Name)
+            {
+                throw new ArgumentException("Cannot update with an instance of a different name");
+            }
+
+            if (updatedInstance.GetType() != ServiceInstance.GetType())
+            {
+                throw new ArgumentException("Cannot update with an instance of a different type");
+            }
+
+            // Update the internal reference based on type
+            if (updatedInstance.GetType() == typeof(ServiceControlInstance))
+            {
+                ServiceControlInstance = (ServiceControlInstance)updatedInstance;
+            }
+            else if (updatedInstance.GetType() == typeof(MonitoringInstance))
+            {
+                MonitoringInstance = (MonitoringInstance)updatedInstance;
+            }
+            else if (updatedInstance.GetType() == typeof(ServiceControlAuditInstance))
+            {
+                ServiceControlAuditInstance = (ServiceControlAuditInstance)updatedInstance;
+            }
+        }
+
+        public BaseService ServiceInstance =>
+            (BaseService)ServiceControlInstance ??
+            (BaseService)MonitoringInstance ??
+            ServiceControlAuditInstance;
 
         public bool InMaintenanceMode =>
             ServiceControlInstance?.InMaintenanceMode == true ||
@@ -165,20 +193,25 @@ string GetDBPathIfAvailable()
 
         public bool HasNewVersion => Version < NewVersion;
 
-        public TransportInfo Transport => ((ITransportConfig)ServiceInstance).TransportPackage;
+        public TransportInfo Transport => HasConfigurationError ? null : ((ITransportConfig)ServiceInstance).TransportPackage;
 
         public string Persister
         {
             get
             {
+                if (HasConfigurationError)
+                {
+                    return string.Empty; // Leave blank for corrupt instances
+                }
+
                 if (ServiceInstance is IServiceControlInstance primaryInstance)
                 {
-                    return primaryInstance.PersistenceManifest.DisplayName;
+                    return primaryInstance.PersistenceManifest?.DisplayName ?? "Unknown";
                 }
 
                 if (ServiceInstance is IServiceControlAuditInstance auditInstance)
                 {
-                    return auditInstance.PersistenceManifest.DisplayName;
+                    return auditInstance.PersistenceManifest?.DisplayName ?? "Unknown";
                 }
 
                 if (ServiceInstance is IMonitoringInstance)
@@ -194,6 +227,12 @@ public string Status
         {
             get
             {
+                // If there's a configuration error, show that instead of service status
+                if (HasConfigurationError)
+                {
+                    return "ERROR";
+                }
+
                 try
                 {
                     return ServiceInstance.Service.Status.ToString().ToUpperInvariant();
@@ -209,6 +248,12 @@ public bool IsRunning
         {
             get
             {
+                // If there's a configuration error, don't show running icon
+                if (HasConfigurationError)
+                {
+                    return false;
+                }
+
                 try
                 {
                     return ServiceInstance.Service.Status != ServiceControllerStatus.Stopped;
@@ -224,6 +269,12 @@ public bool IsStopped
         {
             get
             {
+                // If there's a configuration error, don't show stopped icon either
+                if (HasConfigurationError)
+                {
+                    return false;
+                }
+
                 try
                 {
                     return ServiceInstance.Service.Status == ServiceControllerStatus.Stopped;
@@ -239,6 +290,12 @@ public bool AllowStart
         {
             get
             {
+                // Don't allow start for instances with configuration errors
+                if (HasConfigurationError)
+                {
+                    return false;
+                }
+
                 try
                 {
                     var dontAllowStartOn = new[]
@@ -260,6 +317,12 @@ public bool AllowStop
         {
             get
             {
+                // Don't allow stop for instances with configuration errors
+                if (HasConfigurationError)
+                {
+                    return false;
+                }
+
                 try
                 {
                     var dontAllowStopOn = new[]
@@ -277,6 +340,12 @@ public bool AllowStop
             }
         }
 
+        public bool HasConfigurationError => !string.IsNullOrEmpty(ServiceInstance?.ConfigurationLoadError);
+
+        public bool AllowEdit => !HasConfigurationError; // Disable edit for corrupt instances
+
+        public string ConfigurationErrorMessage => ServiceInstance?.ConfigurationLoadError;
+
         public ICommand OpenUrl { get; private set; }
 
         public ICommand CopyToClipboard { get; private set; }
@@ -308,6 +377,9 @@ public Task HandleAsync(PostRefreshInstances message, CancellationToken cancella
             NotifyOfPropertyChange("Transport");
             NotifyOfPropertyChange("BrowsableUrl");
             NotifyOfPropertyChange("UrlHeading");
+            NotifyOfPropertyChange(nameof(HasConfigurationError));
+            NotifyOfPropertyChange(nameof(AllowEdit));
+            NotifyOfPropertyChange(nameof(ConfigurationErrorMessage));
             return Task.CompletedTask;
         }
 
@@ -376,7 +448,20 @@ await Task.Run(() =>
 
         void UpdateServiceProperties()
         {
-            ServiceInstance.Reload();
+            try
+            {
+                ServiceInstance.Reload();
+            }
+            catch (Exception ex)
+            {
+                // Handle reload failure gracefully - configuration error will be shown in UI
+                ServiceInstance.ConfigurationLoadError = $"Failed to load configuration file '{ServiceInstance.ConfigurationFilePath}': {ex.Message}";
+                // Ensure basic properties are set so UI can still display the instance
+                if (string.IsNullOrEmpty(ServiceInstance.InstanceName))
+                {
+                    ServiceInstance.InstanceName = ServiceInstance.Name;
+                }
+            }
 
             NotifyOfPropertyChange("Status");
             NotifyOfPropertyChange("AllowStop");
diff --git a/src/ServiceControl.Config/UI/ListInstances/ListInstancesView.xaml b/src/ServiceControl.Config/UI/ListInstances/ListInstancesView.xaml
index c7a6b0d731..bde62a0bcd 100644
--- a/src/ServiceControl.Config/UI/ListInstances/ListInstancesView.xaml
+++ b/src/ServiceControl.Config/UI/ListInstances/ListInstancesView.xaml
@@ -3,9 +3,51 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:converters="clr-namespace:ServiceControl.Config.Xaml.Converters"
              mc:Ignorable="d"
              d:DesignHeight="300" d:DesignWidth="300">
-    <ScrollViewer VerticalScrollBarVisibility="Auto">
-        <ItemsControl x:Name="OrderedInstances" Margin="60,0" AlternationCount="{Binding Path=Items.Count}" />
-    </ScrollViewer>
+    <UserControl.Resources>
+        <converters:BoolToVisibilityConverter x:Key="BoolToVisibilityConverter" />
+    </UserControl.Resources>
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+
+        <!-- Configuration Error Summary -->
+        <Border Grid.Row="0" Margin="60,10,60,10"
+                Background="#FFF4E5" BorderBrush="#FFA500" BorderThickness="1" Padding="10" CornerRadius="3"
+                Visibility="{Binding HasConfigurationErrors, Converter={StaticResource BoolToVisibilityConverter}}">
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition Width="Auto"/>
+                    <ColumnDefinition Width="*"/>
+                    <ColumnDefinition Width="Auto"/>
+                </Grid.ColumnDefinitions>
+                <TextBlock Grid.Column="0" Text="⚠" FontSize="16" Foreground="#FFA500" VerticalAlignment="Top" Margin="0,0,8,0" />
+                <StackPanel Grid.Column="1">
+                    <TextBlock Text="CONFIGURATION ERROR"
+                               FontWeight="Bold"
+                               Foreground="#D84315"
+                               FontSize="13"
+                               Margin="0,0,0,5" />
+                    <TextBlock Text="{Binding ConfigurationErrorMessage}"
+                               TextWrapping="Wrap"
+                               Foreground="#5D4037"
+                               FontSize="12" />
+                </StackPanel>
+                <Button Grid.Column="2" Padding="0" Background="Transparent" BorderThickness="0"
+                        VerticalAlignment="Top" Margin="8,0,0,0"
+                        Command="{Binding CopyToClipboard}" CommandParameter="{Binding ConfigurationErrorMessage}"
+                        ToolTip="Copy error message" Cursor="Hand">
+                    <ContentControl Template="{StaticResource CopyIcon}" Foreground="#5D4037" Width="14" Height="14" />
+                </Button>
+            </Grid>
+        </Border>
+
+        <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto">
+            <ItemsControl x:Name="OrderedInstances" Margin="60,0" AlternationCount="{Binding Path=Items.Count}" />
+        </ScrollViewer>
+    </Grid>
 </UserControl>
\ No newline at end of file
diff --git a/src/ServiceControl.Config/UI/ListInstances/ListInstancesViewModel.cs b/src/ServiceControl.Config/UI/ListInstances/ListInstancesViewModel.cs
index e94a4c0eb3..d94a29c949 100644
--- a/src/ServiceControl.Config/UI/ListInstances/ListInstancesViewModel.cs
+++ b/src/ServiceControl.Config/UI/ListInstances/ListInstancesViewModel.cs
@@ -7,6 +7,7 @@
     using System.Threading;
     using System.Threading.Tasks;
     using Caliburn.Micro;
+    using Commands;
     using DynamicData;
     using Events;
     using Framework.Rx;
@@ -19,18 +20,51 @@
     class ListInstancesViewModel : RxScreen, IHandle<RefreshInstances>, IHandle<ResetInstances>, IHandle<LicenseUpdated>
     {
         public ListInstancesViewModel(Func<BaseService, InstanceDetailsViewModel> instanceDetailsFunc)
+            : this(instanceDetailsFunc, InstanceFinder.AllInstances)
+        {
+        }
+
+        internal ListInstancesViewModel(Func<BaseService, InstanceDetailsViewModel> instanceDetailsFunc, Func<IEnumerable<BaseService>> getAllInstances)
         {
             this.instanceDetailsFunc = instanceDetailsFunc;
+            this.getAllInstances = getAllInstances;
             DisplayName = "DEPLOYED INSTANCES";
+            CopyToClipboard = new CopyToClipboardCommand();
 
             Instances = [];
 
             AddAndRemoveInstances();
         }
 
+        public CopyToClipboardCommand CopyToClipboard { get; }
+
         public BindableCollection<InstanceDetailsViewModel> OrderedInstances => [.. Instances.OrderBy(x => x.Name)];
 
-        [AlsoNotifyFor(nameof(OrderedInstances))]
+        public bool HasConfigurationErrors => Instances.Any(i => i.HasConfigurationError);
+
+        public string ConfigurationErrorMessage
+        {
+            get
+            {
+                var errorInstances = Instances.Where(i => i.HasConfigurationError).ToList();
+
+                if (errorInstances.Count == 0)
+                {
+                    return null;
+                }
+
+                if (errorInstances.Count == 1)
+                {
+                    var instance = errorInstances[0];
+                    return $"{instance.Name} instance cannot be loaded due to XML configuration error.";
+                }
+
+                var names = string.Join(", ", errorInstances.Select(i => i.Name));
+                return $"Multiple instances ({names}) cannot be loaded due to XML configuration errors.";
+            }
+        }
+
+        [AlsoNotifyFor(nameof(OrderedInstances), nameof(HasConfigurationErrors), nameof(ConfigurationErrorMessage))]
         IList<InstanceDetailsViewModel> Instances { get; }
 
         public Task HandleAsync(LicenseUpdated licenseUpdatedEvent, CancellationToken cancellationToken)
@@ -86,23 +120,38 @@ public async Task HandleAsync(ResetInstances message, CancellationToken cancella
 
             Instances.Clear();
 
-            foreach (var item in InstanceFinder.AllInstances().OrderBy(i => i.Name))
+            foreach (var item in getAllInstances().OrderBy(i => i.Name))
             {
                 Instances.Add(instanceDetailsFunc(item));
             }
-            NotifyOfPropertyChange(nameof(OrderedInstances));
+            NotifyOfPropertyChange(nameof(Instances));
         }
 
         async void AddAndRemoveInstances()
         {
-            var toRemove = Instances.Where(instance => !instance.Exists());
+            // Remove instances that no longer exist on disk
+            var toRemove = Instances.Where(instance => !instance.Exists()).ToList();
             foreach (var instance in toRemove)
             {
                 await instance.TryCloseAsync();
             }
             Instances.RemoveMany(toRemove);
 
-            var missingInstances = InstanceFinder.AllInstances().Where(i => !Instances.Any(existingInstance => existingInstance.Name == i.Name));
+            // Get fresh instances from disk (with updated configurations)
+            var allFreshInstances = getAllInstances().ToList();
+
+            // Update existing instances with fresh configuration data
+            foreach (var existingInstance in Instances.ToList())
+            {
+                var freshInstance = allFreshInstances.FirstOrDefault(i => i.Name == existingInstance.Name);
+                if (freshInstance != null)
+                {
+                    existingInstance.UpdateServiceInstance(freshInstance);
+                }
+            }
+
+            // Add new instances that weren't in the list before
+            var missingInstances = allFreshInstances.Where(i => !Instances.Any(existingInstance => existingInstance.Name == i.Name));
 
             foreach (var item in missingInstances)
             {
@@ -112,8 +161,11 @@ async void AddAndRemoveInstances()
             Validations.RefreshInstances();
 
             NotifyOfPropertyChange(nameof(OrderedInstances));
+            NotifyOfPropertyChange(nameof(HasConfigurationErrors));
+            NotifyOfPropertyChange(nameof(ConfigurationErrorMessage));
         }
 
         readonly Func<BaseService, InstanceDetailsViewModel> instanceDetailsFunc;
+        readonly Func<IEnumerable<BaseService>> getAllInstances;
     }
 }
\ No newline at end of file
diff --git a/src/ServiceControl.Config/UI/Shell/ShellViewModel.cs b/src/ServiceControl.Config/UI/Shell/ShellViewModel.cs
index bcd58bb12e..ea9328d98f 100644
--- a/src/ServiceControl.Config/UI/Shell/ShellViewModel.cs
+++ b/src/ServiceControl.Config/UI/Shell/ShellViewModel.cs
@@ -15,7 +15,7 @@
     using NuGet.Versioning;
     using ServiceControlInstaller.Engine.Instances;
 
-    class ShellViewModel : RxConductor<RxScreen>.OneActive, IHandle<PostRefreshInstances>
+    class ShellViewModel : RxConductor<RxScreen>.OneActive, IHandle<PostRefreshInstances>, IHandle<ResetInstances>
     {
         public ShellViewModel(
             NoInstancesViewModel noInstances,
@@ -88,6 +88,8 @@ IEventAggregator eventAggregator
 
         public Task HandleAsync(PostRefreshInstances message, CancellationToken cancellationToken) => RefreshInstances();
 
+        public Task HandleAsync(ResetInstances message, CancellationToken cancellationToken) => RefreshInstances();
+
         protected override Task OnInitialize() => RefreshInstances();
 
         protected override async Task OnActivate()
@@ -99,20 +101,18 @@ protected override async Task OnActivate()
 
         public async Task RefreshInstances()
         {
-            if (ActiveItem != null && !(ActiveItem == listInstances || ActiveItem == noInstances))
-            {
-                return;
-            }
-
             HasInstances = InstanceFinder.AllInstances().Any();
 
-            if (HasInstances)
-            {
-                await ActivateItem(listInstances);
-            }
-            else
+            if (ActiveItem == null || ActiveItem == listInstances || ActiveItem == noInstances)
             {
-                await ActivateItem(noInstances);
+                if (HasInstances)
+                {
+                    await ActivateItem(listInstances);
+                }
+                else
+                {
+                    await ActivateItem(noInstances);
+                }
             }
         }
 
diff --git a/src/ServiceControlInstaller.Engine/Configuration/AppConfigWrapper.cs b/src/ServiceControlInstaller.Engine/Configuration/AppConfigWrapper.cs
index b373b16c57..93a4eb513e 100644
--- a/src/ServiceControlInstaller.Engine/Configuration/AppConfigWrapper.cs
+++ b/src/ServiceControlInstaller.Engine/Configuration/AppConfigWrapper.cs
@@ -8,8 +8,18 @@ public class AppConfigWrapper
     {
         public AppConfigWrapper(string configFilePath)
         {
-            var mapping = new ExeConfigurationFileMap { ExeConfigFilename = configFilePath };
-            Config = ConfigurationManager.OpenMappedExeConfiguration(mapping, ConfigurationUserLevel.None);
+            ConfigFilePath = configFilePath;
+
+            try
+            {
+                var mapping = new ExeConfigurationFileMap { ExeConfigFilename = configFilePath };
+                Config = ConfigurationManager.OpenMappedExeConfiguration(mapping, ConfigurationUserLevel.None);
+            }
+            catch (ConfigurationErrorsException ex)
+            {
+                ConfigLoadException = ex;
+                // Don't re-throw - let the caller handle the error via ConfigLoadException
+            }
         }
 
         public T Read<T>(SettingInfo keyInfo, T defaultValue)
@@ -19,7 +29,7 @@ public T Read<T>(SettingInfo keyInfo, T defaultValue)
 
         public T Read<T>(string key, T defaultValue)
         {
-            if (Config.AppSettings.Settings.AllKeys.Contains(key, StringComparer.OrdinalIgnoreCase))
+            if (Config?.AppSettings.Settings.AllKeys.Contains(key, StringComparer.OrdinalIgnoreCase) == true)
             {
                 var nonNullableType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
                 return (T)Convert.ChangeType(Config.AppSettings.Settings[key].Value, nonNullableType);
@@ -40,9 +50,11 @@ public T Read<T>(string key, T defaultValue)
 
         public bool AppSettingExists(string key)
         {
-            return Config.AppSettings.Settings.AllKeys.Contains(key, StringComparer.OrdinalIgnoreCase);
+            return Config?.AppSettings.Settings.AllKeys.Contains(key, StringComparer.OrdinalIgnoreCase) == true;
         }
 
         public Configuration Config;
+        public string ConfigFilePath;
+        public Exception ConfigLoadException;
     }
 }
\ No newline at end of file
diff --git a/src/ServiceControlInstaller.Engine/Instances/BaseService.cs b/src/ServiceControlInstaller.Engine/Instances/BaseService.cs
index 493b413469..8306210291 100644
--- a/src/ServiceControlInstaller.Engine/Instances/BaseService.cs
+++ b/src/ServiceControlInstaller.Engine/Instances/BaseService.cs
@@ -32,6 +32,10 @@ public abstract class BaseService : IServiceInstance
 
         public TransportInfo TransportPackage { get; set; }
 
+        public string ConfigurationLoadError { get; set; }
+
+        public string ConfigurationFilePath { get; set; }
+
         public SemanticVersion Version
         {
             get
diff --git a/src/ServiceControlInstaller.Engine/Instances/MonitoringInstance.cs b/src/ServiceControlInstaller.Engine/Instances/MonitoringInstance.cs
index 2b3f93c4ca..09a91d848c 100644
--- a/src/ServiceControlInstaller.Engine/Instances/MonitoringInstance.cs
+++ b/src/ServiceControlInstaller.Engine/Instances/MonitoringInstance.cs
@@ -3,6 +3,7 @@
     using System;
     using System.Configuration;
     using System.IO;
+    using System.Linq;
     using System.Security.AccessControl;
     using System.Security.Principal;
     using System.Threading.Tasks;
@@ -17,11 +18,25 @@
 
     public class MonitoringInstance : BaseService, IMonitoringInstance
     {
-        public MonitoringInstance(WindowsServiceController service)
+        public MonitoringInstance(IWindowsServiceController service)
         {
             Service = service;
-            AppConfig = new AppConfig(this);
-            Reload();
+
+            // Set the config file path so it's available if loading fails
+            ConfigurationFilePath = Path.Combine(InstallPath, $"{Constants.MonitoringExe}.config");
+
+            try
+            {
+                AppConfig = new AppConfig(this);
+                Reload();
+            }
+            catch (Exception ex)
+            {
+                ConfigurationLoadError = $"Failed to load configuration file '{ConfigurationFilePath}': {ex.Message}";
+                InstanceName = Name;
+                ReportCard = new ReportCard();
+                ReportCard.Errors.Add(ConfigurationLoadError);
+            }
         }
 
         public AppConfig AppConfig { get; set; }
@@ -65,6 +80,12 @@ public override void Reload()
 
             AppConfig = new AppConfig(this);
 
+            // If config failed to load, throw exception to be caught by constructor
+            if (AppConfig.Config == null)
+            {
+                throw new Exception(AppConfig.ConfigLoadException?.Message ?? "Unknown error", AppConfig.ConfigLoadException);
+            }
+
             InstanceName = AppConfig.Read(SettingsList.InstanceName, Name);
             HostName = AppConfig.Read(SettingsList.HostName, "localhost");
             Port = AppConfig.Read(SettingsList.Port, 1234);
diff --git a/src/ServiceControlInstaller.Engine/Instances/ServiceControlAuditInstance.cs b/src/ServiceControlInstaller.Engine/Instances/ServiceControlAuditInstance.cs
index d0b908b2a9..e280cfaba9 100644
--- a/src/ServiceControlInstaller.Engine/Instances/ServiceControlAuditInstance.cs
+++ b/src/ServiceControlInstaller.Engine/Instances/ServiceControlAuditInstance.cs
@@ -16,7 +16,30 @@ public class ServiceControlAuditInstance : ServiceControlBaseService, IServiceCo
     {
         public ServiceControlAuditInstance(IWindowsServiceController service) : base(service)
         {
-            Reload();
+            // Set the config file path so it's available if loading fails
+            ConfigurationFilePath = Path.Combine(InstallPath, $"{Constants.ServiceControlAuditExe}.config");
+
+            // Check if config loading failed in base constructor
+            if (ConfigurationLoadException != null)
+            {
+                ConfigurationLoadError = $"Failed to load configuration file '{ConfigurationFilePath}': {ConfigurationLoadException.Message}";
+                InstanceName = Name;
+                ReportCard = new ReportCard.ReportCard();
+                ReportCard.Errors.Add(ConfigurationLoadError);
+                return;
+            }
+
+            try
+            {
+                Reload();
+            }
+            catch (Exception ex)
+            {
+                ConfigurationLoadError = $"Failed to load configuration file '{ConfigurationFilePath}': {ex.Message}";
+                InstanceName = Name;
+                ReportCard = new ReportCard.ReportCard();
+                ReportCard.Errors.Add(ConfigurationLoadError);
+            }
         }
 
         public TimeSpan AuditRetentionPeriod { get; set; }
@@ -72,6 +95,12 @@ public override void Reload()
 
             AppConfig = CreateAppConfig();
 
+            // If config failed to load, throw exception to be caught by constructor
+            if (AppConfig.Config == null)
+            {
+                throw new Exception(AppConfig.ConfigLoadException?.Message ?? "Unknown error", AppConfig.ConfigLoadException);
+            }
+
             InstanceName = AppConfig.Read(AuditInstanceSettingsList.InternalQueueName, Name);
             InstanceName = AppConfig.Read(AuditInstanceSettingsList.InstanceName, InstanceName);
 
diff --git a/src/ServiceControlInstaller.Engine/Instances/ServiceControlBaseService.cs b/src/ServiceControlInstaller.Engine/Instances/ServiceControlBaseService.cs
index a5e2294538..b0c5916ff1 100644
--- a/src/ServiceControlInstaller.Engine/Instances/ServiceControlBaseService.cs
+++ b/src/ServiceControlInstaller.Engine/Instances/ServiceControlBaseService.cs
@@ -20,10 +20,21 @@ namespace ServiceControlInstaller.Engine.Instances
 
     public abstract class ServiceControlBaseService : BaseService
     {
+        protected Exception ConfigurationLoadException { get; set; }
+
         protected ServiceControlBaseService(IWindowsServiceController service)
         {
             Service = service;
-            AppConfig = CreateAppConfig();
+            try
+            {
+                AppConfig = CreateAppConfig();
+            }
+            catch (Exception ex)
+            {
+                // Config loading failed - will be handled by derived class constructor
+                // Store the exception so derived class can log it
+                ConfigurationLoadException = ex;
+            }
         }
 
         public bool InMaintenanceMode { get; set; }
diff --git a/src/ServiceControlInstaller.Engine/Instances/ServiceControlInstance.cs b/src/ServiceControlInstaller.Engine/Instances/ServiceControlInstance.cs
index d010a64a20..9817315782 100644
--- a/src/ServiceControlInstaller.Engine/Instances/ServiceControlInstance.cs
+++ b/src/ServiceControlInstaller.Engine/Instances/ServiceControlInstance.cs
@@ -19,7 +19,30 @@ public class ServiceControlInstance : ServiceControlBaseService, IServiceControl
     {
         public ServiceControlInstance(IWindowsServiceController service) : base(service)
         {
-            Reload();
+            // Set the config file path so it's available if loading fails
+            ConfigurationFilePath = Path.Combine(InstallPath, $"{Constants.ServiceControlExe}.config");
+
+            // Check if config loading failed in base constructor
+            if (ConfigurationLoadException != null)
+            {
+                ConfigurationLoadError = $"Failed to load configuration file '{ConfigurationFilePath}': {ConfigurationLoadException.Message}";
+                InstanceName = Name;
+                ReportCard = new ReportCard.ReportCard();
+                ReportCard.Errors.Add(ConfigurationLoadError);
+                return;
+            }
+
+            try
+            {
+                Reload();
+            }
+            catch (Exception ex)
+            {
+                ConfigurationLoadError = $"Failed to load configuration file '{ConfigurationFilePath}': {ex.Message}";
+                InstanceName = Name;
+                ReportCard = new ReportCard.ReportCard();
+                ReportCard.Errors.Add(ConfigurationLoadError);
+            }
         }
 
         protected override string BaseServiceName => "ServiceControl";
@@ -103,6 +126,12 @@ public override void Reload()
 
             AppConfig = CreateAppConfig();
 
+            // If config failed to load, throw exception to be caught by constructor
+            if (AppConfig.Config == null)
+            {
+                throw new Exception(AppConfig.ConfigLoadException?.Message ?? "Unknown error", AppConfig.ConfigLoadException);
+            }
+
             InstanceName = AppConfig.Read(ServiceControlSettings.InternalQueueName, Name);
             InstanceName = AppConfig.Read(ServiceControlSettings.InstanceName, InstanceName);
 
diff --git a/src/ServiceControlInstaller.Engine/Validation/QueueNameValidator.cs b/src/ServiceControlInstaller.Engine/Validation/QueueNameValidator.cs
index 40ee76e9fc..418c3f16fb 100644
--- a/src/ServiceControlInstaller.Engine/Validation/QueueNameValidator.cs
+++ b/src/ServiceControlInstaller.Engine/Validation/QueueNameValidator.cs
@@ -27,8 +27,8 @@ public static void Validate(IServiceControlInstance instance)
         {
             var validator = new QueueNameValidator(instance)
             {
-                SCInstances = InstanceFinder.ServiceControlInstances().Where(p => p.Name != instance.Name & p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlInstance>().ToList(),
-                AuditInstances = InstanceFinder.ServiceControlAuditInstances().Where(p => p.Name != instance.Name & p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlAuditInstance>().ToList(),
+                SCInstances = InstanceFinder.ServiceControlInstances().Where(p => p.Name != instance.Name && p.TransportPackage != null && string.IsNullOrEmpty(p.ConfigurationLoadError) && p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlInstance>().ToList(),
+                AuditInstances = InstanceFinder.ServiceControlAuditInstances().Where(p => p.Name != instance.Name && p.TransportPackage != null && string.IsNullOrEmpty(p.ConfigurationLoadError) && p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlAuditInstance>().ToList(),
             };
 
             validator.RunValidation();
@@ -38,8 +38,8 @@ public static void Validate(IServiceControlAuditInstance instance)
         {
             var validator = new QueueNameValidator(instance)
             {
-                SCInstances = InstanceFinder.ServiceControlInstances().Where(p => p.Name != instance.Name & p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlInstance>().ToList(),
-                AuditInstances = InstanceFinder.ServiceControlAuditInstances().Where(p => p.Name != instance.Name & p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlAuditInstance>().ToList(),
+                SCInstances = InstanceFinder.ServiceControlInstances().Where(p => p.Name != instance.Name && p.TransportPackage != null && string.IsNullOrEmpty(p.ConfigurationLoadError) && p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlInstance>().ToList(),
+                AuditInstances = InstanceFinder.ServiceControlAuditInstances().Where(p => p.Name != instance.Name && p.TransportPackage != null && string.IsNullOrEmpty(p.ConfigurationLoadError) && p.TransportPackage.Equals(instance.TransportPackage)).AsEnumerable<IServiceControlAuditInstance>().ToList(),
             };
 
             validator.RunValidation();