diff --git a/src/ConnectedMode.UnitTests/UI/ConnectedModeBindingServicesTests.cs b/src/ConnectedMode.UnitTests/UI/ConnectedModeBindingServicesTests.cs
new file mode 100644
index 000000000..61b741097
--- /dev/null
+++ b/src/ConnectedMode.UnitTests/UI/ConnectedModeBindingServicesTests.cs
@@ -0,0 +1,40 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using SonarLint.VisualStudio.Core;
+using SonarLint.VisualStudio.TestInfrastructure;
+using SonarLint.VisualStudio.ConnectedMode.UI;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
+using SonarLint.VisualStudio.ConnectedMode.Binding;
+
+namespace SonarLint.VisualStudio.ConnectedMode.UnitTests.UI;
+
+[TestClass]
+public class ConnectedModeBindingServicesTests
+{
+    [TestMethod]
+    public void MefCtor_CheckIsExported()
+    {
+        MefTestHelpers.CheckTypeCanBeImported<ConnectedModeBindingServices, IConnectedModeBindingServices>(
+            MefTestHelpers.CreateExport<IBindingController>(),
+            MefTestHelpers.CreateExport<ISolutionInfoProvider>(),
+            MefTestHelpers.CreateExport<ISharedBindingConfigProvider>());
+    }
+}
diff --git a/src/ConnectedMode.UnitTests/UI/ConnectedModeServicesTests.cs b/src/ConnectedMode.UnitTests/UI/ConnectedModeServicesTests.cs
index 9dd7fab8b..333fd1d92 100644
--- a/src/ConnectedMode.UnitTests/UI/ConnectedModeServicesTests.cs
+++ b/src/ConnectedMode.UnitTests/UI/ConnectedModeServicesTests.cs
@@ -22,7 +22,6 @@
 using SonarLint.VisualStudio.TestInfrastructure;
 using SonarLint.VisualStudio.ConnectedMode.UI;
 using SonarLint.VisualStudio.Core.Binding;
-using SonarLint.VisualStudio.ConnectedMode.Shared;
 
 namespace SonarLint.VisualStudio.ConnectedMode.UnitTests.UI;
 
@@ -37,8 +36,8 @@ public void MefCtor_CheckIsExported()
             MefTestHelpers.CreateExport<IThreadHandling>(),
             MefTestHelpers.CreateExport<ISlCoreConnectionAdapter>(),
             MefTestHelpers.CreateExport<IConfigurationProvider>(),
-            MefTestHelpers.CreateExport<ISharedBindingConfigProvider>(),
             MefTestHelpers.CreateExport<IServerConnectionsRepositoryAdapter>(),
+            MefTestHelpers.CreateExport<IMessageBox>(),
             MefTestHelpers.CreateExport<ILogger>());
     }
 }
diff --git a/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs b/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs
index ab33e7557..4557d178b 100644
--- a/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs
+++ b/src/ConnectedMode.UnitTests/UI/ManageBinding/ManageBindingViewModelTests.cs
@@ -20,9 +20,11 @@
 
 using System.ComponentModel;
 using System.Security;
+using System.Windows;
 using NSubstitute.ExceptionExtensions;
 using SonarLint.VisualStudio.ConnectedMode.Binding;
 using SonarLint.VisualStudio.ConnectedMode.Persistence;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.ConnectedMode.UI;
 using SonarLint.VisualStudio.ConnectedMode.UI.ManageBinding;
 using SonarLint.VisualStudio.ConnectedMode.UI.ProjectSelection;
@@ -41,7 +43,9 @@ public class ManageBindingViewModelTests
     private readonly ConnectionInfo sonarQubeConnectionInfo = new ("http://localhost:9000", ConnectionServerType.SonarQube);
     private readonly ConnectionInfo sonarCloudConnectionInfo = new ("organization", ConnectionServerType.SonarCloud);
     private readonly BasicAuthCredentials validCredentials = new ("TOKEN", new SecureString());
-    
+    private readonly SharedBindingConfigModel sonarQubeSharedBindingConfigModel = new() { Uri = new Uri("http://localhost:9000"), ProjectKey = "myProj" };
+    private readonly SharedBindingConfigModel sonarCloudSharedBindingConfigModel = new() { Organization = "myOrg", ProjectKey = "myProj" };
+
     private ManageBindingViewModel testSubject;
     private IServerConnectionsRepositoryAdapter serverConnectionsRepositoryAdapter;
     private IConnectedModeServices connectedModeServices;
@@ -50,15 +54,18 @@ public class ManageBindingViewModelTests
     private IProgressReporterViewModel progressReporterViewModel;
     private IThreadHandling threadHandling;
     private ILogger logger;
+    private IConnectedModeBindingServices connectedModeBindingServices;
+    private ISharedBindingConfigProvider sharedBindingConfigProvider;
+    private IMessageBox messageBox;
 
     [TestInitialize]
     public void TestInitialize()
     {
         connectedModeServices = Substitute.For<IConnectedModeServices>();
-        bindingController = Substitute.For<IBindingController>();
-        solutionInfoProvider = Substitute.For<ISolutionInfoProvider>();
         progressReporterViewModel = Substitute.For<IProgressReporterViewModel>();
-        testSubject = new ManageBindingViewModel(connectedModeServices, bindingController, solutionInfoProvider, progressReporterViewModel);
+        connectedModeBindingServices = Substitute.For<IConnectedModeBindingServices>();
+
+        testSubject = new ManageBindingViewModel(connectedModeServices, connectedModeBindingServices, progressReporterViewModel);
 
         MockServices();
     }
@@ -98,6 +105,8 @@ public void BoundProject_Set_RaisesEvents()
             Arg.Is<PropertyChangedEventArgs>(x => x.PropertyName == nameof(testSubject.IsSelectProjectButtonEnabled)));
         eventHandler.Received().Invoke(testSubject,
             Arg.Is<PropertyChangedEventArgs>(x => x.PropertyName == nameof(testSubject.IsExportButtonEnabled)));
+        eventHandler.Received().Invoke(testSubject,
+            Arg.Is<PropertyChangedEventArgs>(x => x.PropertyName == nameof(testSubject.IsUseSharedBindingButtonVisible)));
     }
 
     [TestMethod]
@@ -252,38 +261,24 @@ public void IsManageConnectionsButtonEnabled_ReturnsTrueOnlyWhenNoBindingIsInPro
     [TestMethod]
     [DataRow(true, false)]
     [DataRow(false, true)]
-    public void IsUseSharedBindingButtonEnabled_SharedBindingConfigurationIsDetected_ReturnsTrueOnlyWhenNoBindingIsInProgress(bool isBindingInProgress, bool expectedResult)
+    public void IsUseSharedBindingButtonEnabled_ReturnsTrueOnlyWhenNoBindingIsInProgress(bool isBindingInProgress, bool expectedResult)
     {
-        testSubject.IsSharedBindingConfigurationDetected = true;
         progressReporterViewModel.IsOperationInProgress.Returns(isBindingInProgress);
 
         testSubject.IsUseSharedBindingButtonEnabled.Should().Be(expectedResult);
     }
 
     [TestMethod]
-    [DataRow(true)]
-    [DataRow(null)]
-    public void IsUseSharedBindingButtonEnabled_SharedBindingConfigurationIsNotDetected_ReturnsFalse(bool isBindingInProgress)
-    {
-        testSubject.IsSharedBindingConfigurationDetected = false;
-        progressReporterViewModel.IsOperationInProgress.Returns(isBindingInProgress);
-
-        testSubject.IsUseSharedBindingButtonEnabled.Should().BeFalse();
-    }
-
-    [TestMethod]
-    public void IsSharedBindingConfigurationDetected_Set_RaisesEvents()
+    public void SharedBindingConfigModel_Set_RaisesEvents()
     {
         var eventHandler = Substitute.For<PropertyChangedEventHandler>();
         testSubject.PropertyChanged += eventHandler;
         eventHandler.ReceivedCalls().Should().BeEmpty();
 
-        testSubject.IsSharedBindingConfigurationDetected = true;
+        testSubject.SharedBindingConfigModel = new SharedBindingConfigModel();
 
         eventHandler.Received().Invoke(testSubject,
-            Arg.Is<PropertyChangedEventArgs>(x => x.PropertyName == nameof(testSubject.IsSharedBindingConfigurationDetected)));
-        eventHandler.Received().Invoke(testSubject,
-            Arg.Is<PropertyChangedEventArgs>(x => x.PropertyName == nameof(testSubject.IsUseSharedBindingButtonEnabled)));
+            Arg.Is<PropertyChangedEventArgs>(x => x.PropertyName == nameof(testSubject.IsUseSharedBindingButtonVisible)));
     }
 
     [TestMethod]
@@ -723,15 +718,170 @@ public async Task BindAsync_WhenBindingCompletesSuccessfully_SetsBoundProjectToS
         testSubject.BoundProject.Should().BeEquivalentTo(serverProject);
     }
 
+    [TestMethod]
+    public void DetectSharedBinding_CurrentProjectBound_DoesNothing()
+    {
+        testSubject.BoundProject = serverProject;
+
+        testSubject.DetectSharedBinding();
+
+        sharedBindingConfigProvider.DidNotReceive().GetSharedBinding();
+    }
+
+    [TestMethod]
+    public void DetectSharedBinding_CurrentProjectNotBound_UpdatesSharedBindingConfigModel()
+    {
+        testSubject.BoundProject = null;
+        var sharedBindingModel = new SharedBindingConfigModel();
+        sharedBindingConfigProvider.GetSharedBinding().Returns(sharedBindingModel);
+
+        testSubject.DetectSharedBinding();
+
+        sharedBindingConfigProvider.Received(1).GetSharedBinding();
+        testSubject.SharedBindingConfigModel.Should().Be(sharedBindingModel);
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingWithProgressAsync_SharedBindingExistsAndValid_BindsProjectAndReportsProgress()
+    {
+        testSubject.SharedBindingConfigModel = sonarQubeSharedBindingConfigModel;
+
+        await testSubject.UseSharedBindingWithProgressAsync();
+
+        await progressReporterViewModel.Received(1)
+            .ExecuteTaskWithProgressAsync(
+                Arg.Is<TaskToPerformParams<AdapterResponse>>(x =>
+                    x.TaskToPerform == testSubject.UseSharedBindingAsync &&
+                    x.ProgressStatus == UiResources.BindingInProgressText &&
+                    x.WarningText == UiResources.BindingFailedText &&
+                    x.AfterProgressUpdated == testSubject.OnProgressUpdated));
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_SharedBindingForSonarQubeConnection_BindsWithTheCorrectProjectKey()
+    {
+        testSubject.SelectedProject = serverProject; // this is to make sure the SelectedProject is ignored and the shared config is used instead
+        testSubject.SharedBindingConfigModel = sonarQubeSharedBindingConfigModel;
+        SetupBoundProject(new ServerConnection.SonarQube(testSubject.SharedBindingConfigModel.Uri));
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeTrue();
+        await bindingController.Received(1)
+            .BindAsync(Arg.Is<BoundServerProject>(proj =>
+                    proj.ServerProjectKey == testSubject.SharedBindingConfigModel.ProjectKey), Arg.Any<CancellationToken>());
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_SharedBindingForSonarCloudConnection_BindsWithTheCorrectProjectKey()
+    {
+        testSubject.SelectedConnectionInfo = sonarQubeConnectionInfo; // this is to make sure the SelectedConnectionInfo is ignored and the shared config is used instead
+        testSubject.SharedBindingConfigModel = sonarCloudSharedBindingConfigModel;
+        SetupBoundProject(new ServerConnection.SonarCloud(testSubject.SharedBindingConfigModel.Organization));
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeTrue();
+        await bindingController.Received(1)
+            .BindAsync(Arg.Is<BoundServerProject>(proj =>
+                proj.ServerProjectKey == testSubject.SharedBindingConfigModel.ProjectKey), Arg.Any<CancellationToken>());
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_SharedBindingForExistSonarQubeConnection_BindsWithTheCorrectConnectionId()
+    {
+        testSubject.SelectedConnectionInfo = sonarCloudConnectionInfo; // this is to make sure the SelectedConnectionInfo is ignored and the shared config is used instead
+        testSubject.SharedBindingConfigModel = sonarQubeSharedBindingConfigModel;
+        var expectedServerConnection = new ServerConnection.SonarQube(testSubject.SharedBindingConfigModel.Uri);
+        SetupBoundProject(expectedServerConnection);
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeTrue();
+        serverConnectionsRepositoryAdapter.Received(1).TryGetServerConnectionById(testSubject.SharedBindingConfigModel.Uri.ToString(), out _);
+        await bindingController.Received(1)
+            .BindAsync(Arg.Is<BoundServerProject>(proj => proj.ServerConnection == expectedServerConnection), Arg.Any<CancellationToken>());
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_SharedBindingForExistingSonarCloudConnection_BindsWithTheCorrectConnectionId()
+    {
+        testSubject.SelectedProject = serverProject; // this is to make sure the SelectedProject is ignored and the shared config is used instead
+        testSubject.SharedBindingConfigModel = sonarCloudSharedBindingConfigModel;
+        var expectedServerConnection  = new ServerConnection.SonarCloud(testSubject.SharedBindingConfigModel.Organization);
+        SetupBoundProject(expectedServerConnection);
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeTrue();
+        serverConnectionsRepositoryAdapter.Received(1).TryGetServerConnectionById(testSubject.SharedBindingConfigModel.Organization, out _);
+        await bindingController.Received(1)
+            .BindAsync(Arg.Is<BoundServerProject>(proj => proj.ServerConnection == expectedServerConnection), Arg.Any<CancellationToken>());
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_SharedBindingForNonExistingSonarQubeConnection_ReturnsFalseAndLogsAndInformsUser()
+    {
+        testSubject.SelectedProject = serverProject; // this is to make sure the SelectedProject is ignored and the shared config is used instead
+        testSubject.SharedBindingConfigModel = sonarQubeSharedBindingConfigModel;
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeFalse();
+        messageBox.Received(1).Show(UiResources.NotFoundConnectionForSharedBindingMessageBoxText, UiResources.NotFoundConnectionForSharedBindingMessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Warning);
+        logger.WriteLine(Resources.UseSharedBinding_ConnectionNotFound, testSubject.SharedBindingConfigModel.Uri);
+        await bindingController.DidNotReceive()
+            .BindAsync(Arg.Is<BoundServerProject>(proj =>
+                proj.ServerProjectKey == testSubject.SharedBindingConfigModel.ProjectKey), Arg.Any<CancellationToken>());
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_SharedBindingForNonExistingSonarCloudConnection_ReturnsFalseAndLogsAndInformsUser()
+    {
+        testSubject.SelectedProject = serverProject; // this is to make sure the SelectedProject is ignored and the shared config is used instead
+        testSubject.SharedBindingConfigModel = sonarCloudSharedBindingConfigModel;
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeFalse();
+        logger.WriteLine(Resources.UseSharedBinding_ConnectionNotFound, testSubject.SharedBindingConfigModel.Organization);
+        messageBox.Received(1).Show(UiResources.NotFoundConnectionForSharedBindingMessageBoxText, UiResources.NotFoundConnectionForSharedBindingMessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Warning);
+        await bindingController.DidNotReceive()
+            .BindAsync(Arg.Is<BoundServerProject>(proj =>
+                proj.ServerProjectKey == testSubject.SharedBindingConfigModel.ProjectKey), Arg.Any<CancellationToken>());
+    }
+
+    [TestMethod]
+    public async Task UseSharedBindingAsync_BindingFails_ReturnsFalse()
+    {
+        MockTryGetServerConnectionId();
+        bindingController.When(x => x.BindAsync(Arg.Any<BoundServerProject>(), Arg.Any<CancellationToken>()))
+            .Do(_ => throw new Exception());
+        testSubject.SharedBindingConfigModel = sonarCloudSharedBindingConfigModel;
+
+        var response = await testSubject.UseSharedBindingAsync();
+
+        response.Success.Should().BeFalse();
+    }
+
     private void MockServices()
     {
         serverConnectionsRepositoryAdapter = Substitute.For<IServerConnectionsRepositoryAdapter>();
         threadHandling = Substitute.For<IThreadHandling>();
         logger = Substitute.For<ILogger>();
+        messageBox = Substitute.For<IMessageBox>();
 
         connectedModeServices.ServerConnectionsRepositoryAdapter.Returns(serverConnectionsRepositoryAdapter);
         connectedModeServices.ThreadHandling.Returns(threadHandling);
         connectedModeServices.Logger.Returns(logger);
+        connectedModeServices.MessageBox.Returns(messageBox);
+
+        bindingController = Substitute.For<IBindingController>();
+        solutionInfoProvider = Substitute.For<ISolutionInfoProvider>();
+        sharedBindingConfigProvider = Substitute.For<ISharedBindingConfigProvider>();
+        connectedModeBindingServices.BindingController.Returns(bindingController);
+        connectedModeBindingServices.SolutionInfoProvider.Returns(solutionInfoProvider);
+        connectedModeBindingServices.SharedBindingConfigProvider.Returns(sharedBindingConfigProvider);
 
         MockTryGetAllConnectionsInfo([]);
     }
@@ -760,16 +910,21 @@ private void SetupBoundProject(ServerConnection serverConnection, ServerProject
         var configurationProvider = Substitute.For<IConfigurationProvider>();
         configurationProvider.GetConfiguration().Returns(new BindingConfiguration(boundServerProject, SonarLintMode.Connected, "binding-dir"));
         connectedModeServices.ConfigurationProvider.Returns(configurationProvider);
-        serverConnectionsRepositoryAdapter.TryGetServerConnectionById(serverConnection.Id, out _).Returns(callInfo =>
+        MockTryGetServerConnectionId(serverConnection);
+        solutionInfoProvider.GetSolutionNameAsync().Returns(ALocalProjectKey);
+        
+        MockGetServerProjectByKey(true, expectedServerProject);
+    }
+
+    private void MockTryGetServerConnectionId(ServerConnection serverConnection = null)
+    {
+        serverConnectionsRepositoryAdapter.TryGetServerConnectionById(serverConnection?.Id ?? Arg.Any<string>(), out _).Returns(callInfo =>
         {
             callInfo[1] = serverConnection;
             return true;
         });
-        solutionInfoProvider.GetSolutionNameAsync().Returns(ALocalProjectKey);
-        
-        MockGetServerProjectByKey(true, expectedServerProject);
     }
-    
+
     private void SetupUnboundProject()
     {
         var configurationProvider = Substitute.For<IConfigurationProvider>();
diff --git a/src/ConnectedMode/Resources.Designer.cs b/src/ConnectedMode/Resources.Designer.cs
index 04f9adddd..4704aa2ab 100644
--- a/src/ConnectedMode/Resources.Designer.cs
+++ b/src/ConnectedMode/Resources.Designer.cs
@@ -1,6 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -635,6 +636,15 @@ internal static string TimedUpdateTriggered {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to [ConnectedMode/UseSharedBinding] Connection to server {0} could not be found.
+        /// </summary>
+        internal static string UseSharedBinding_ConnectionNotFound {
+            get {
+                return ResourceManager.GetString("UseSharedBinding_ConnectionNotFound", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to [ConnectedMode] Validating credentials failed.
         /// </summary>
diff --git a/src/ConnectedMode/Resources.resx b/src/ConnectedMode/Resources.resx
index 10ace0365..2a87e5d08 100644
--- a/src/ConnectedMode/Resources.resx
+++ b/src/ConnectedMode/Resources.resx
@@ -319,4 +319,7 @@
   <data name="Binding_Fails" xml:space="preserve">
     <value>[ConnectedMode] Binding failed due to: {0}</value>
   </data>
+  <data name="UseSharedBinding_ConnectionNotFound" xml:space="preserve">
+    <value>[ConnectedMode/UseSharedBinding] Connection to server {0} could not be found</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/ConnectedMode/UI/ConnectedModeBindingServices.cs b/src/ConnectedMode/UI/ConnectedModeBindingServices.cs
new file mode 100644
index 000000000..79e48054c
--- /dev/null
+++ b/src/ConnectedMode/UI/ConnectedModeBindingServices.cs
@@ -0,0 +1,47 @@
+/*
+ * SonarLint for Visual Studio
+ * Copyright (C) 2016-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using System.ComponentModel.Composition;
+using SonarLint.VisualStudio.ConnectedMode.Binding;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
+using SonarLint.VisualStudio.Core;
+
+namespace SonarLint.VisualStudio.ConnectedMode.UI;
+
+public interface IConnectedModeBindingServices
+{
+    public IBindingController BindingController { get; }
+    public ISolutionInfoProvider SolutionInfoProvider { get; }
+    public ISharedBindingConfigProvider SharedBindingConfigProvider { get; }
+}
+
+[Export(typeof(IConnectedModeBindingServices))]
+[PartCreationPolicy(CreationPolicy.Shared)]
+[method: ImportingConstructor]
+public class ConnectedModeBindingServices(
+    IBindingController bindingController,
+    ISolutionInfoProvider solutionInfoProvider,
+    ISharedBindingConfigProvider sharedBindingConfigProvider)
+    : IConnectedModeBindingServices
+{
+    public IBindingController BindingController { get; } = bindingController;
+    public ISolutionInfoProvider SolutionInfoProvider { get; } = solutionInfoProvider;
+    public ISharedBindingConfigProvider SharedBindingConfigProvider { get; } = sharedBindingConfigProvider;
+}
diff --git a/src/ConnectedMode/UI/ConnectedModeServices.cs b/src/ConnectedMode/UI/ConnectedModeServices.cs
index fa62c5457..0bdd1ee90 100644
--- a/src/ConnectedMode/UI/ConnectedModeServices.cs
+++ b/src/ConnectedMode/UI/ConnectedModeServices.cs
@@ -27,13 +27,13 @@ namespace SonarLint.VisualStudio.ConnectedMode.UI;
 
 public interface IConnectedModeServices
 {
-    public ISharedBindingConfigProvider SharedBindingConfigProvider { get; } 
     public IBrowserService BrowserService { get; } 
     public IThreadHandling ThreadHandling { get; } 
     public ILogger Logger { get; } 
     public ISlCoreConnectionAdapter SlCoreConnectionAdapter { get; } 
     public IConfigurationProvider ConfigurationProvider { get; } 
     public IServerConnectionsRepositoryAdapter ServerConnectionsRepositoryAdapter { get; }
+    public IMessageBox MessageBox { get; }
 }
 
 [Export(typeof(IConnectedModeServices))]
@@ -44,13 +44,13 @@ public class ConnectedModeServices(
     IThreadHandling threadHandling,
     ISlCoreConnectionAdapter slCoreConnectionAdapter,
     IConfigurationProvider configurationProvider,
-    ISharedBindingConfigProvider sharedBindingConfigProvider,
     IServerConnectionsRepositoryAdapter serverConnectionsRepositoryAdapter,
+    IMessageBox messageBox,
     ILogger logger)
     : IConnectedModeServices
 {
-    public ISharedBindingConfigProvider SharedBindingConfigProvider { get; } = sharedBindingConfigProvider;
     public IServerConnectionsRepositoryAdapter ServerConnectionsRepositoryAdapter { get; } = serverConnectionsRepositoryAdapter;
+    public IMessageBox MessageBox { get; } = messageBox;
     public IBrowserService BrowserService { get; } = browserService;
     public IThreadHandling ThreadHandling { get; } = threadHandling;
     public ILogger Logger { get; } = logger;
diff --git a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml
index 0323f7376..5c6292a94 100644
--- a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml
+++ b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml
@@ -57,7 +57,9 @@
                     </Grid>
 
             <Button Grid.Column="1" HorizontalAlignment="Right" Content="{x:Static res:UiResources.UseSharedBindingButton}" Padding="5,0" 
-                    IsEnabled="{Binding Path=IsUseSharedBindingButtonEnabled}" ToolTipService.ShowOnDisabled="True"
+                    IsEnabled="{Binding Path=IsUseSharedBindingButtonEnabled}"
+                    Visibility="{Binding Path=IsUseSharedBindingButtonVisible, Converter={StaticResource TrueToVisibleConverter}}"
+                    ToolTipService.ShowOnDisabled="True"
                     Click="UseSharedBinding_OnClick">
                 <Button.Style>
                     <Style TargetType="Button">
diff --git a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs
index db656f197..03125147b 100644
--- a/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs
+++ b/src/ConnectedMode/UI/ManageBinding/ManageBindingDialog.xaml.cs
@@ -22,10 +22,8 @@
 using System.Windows;
 using System.Windows.Navigation;
 using Microsoft.VisualStudio.Threading;
-using SonarLint.VisualStudio.ConnectedMode.Binding;
 using SonarLint.VisualStudio.ConnectedMode.UI.ManageConnections;
 using SonarLint.VisualStudio.ConnectedMode.UI.ProjectSelection;
-using SonarLint.VisualStudio.Core;
 
 namespace SonarLint.VisualStudio.ConnectedMode.UI.ManageBinding;
 
@@ -33,11 +31,16 @@ namespace SonarLint.VisualStudio.ConnectedMode.UI.ManageBinding;
 public partial class ManageBindingDialog : Window
 {
     private readonly IConnectedModeServices connectedModeServices;
+    private readonly bool useSharedBindingOnInitialization;
 
-    public ManageBindingDialog(IConnectedModeServices connectedModeServices, IBindingController bindingController, ISolutionInfoProvider solutionInfoProvider)
+    public ManageBindingDialog(
+        IConnectedModeServices connectedModeServices,
+        IConnectedModeBindingServices connectedModeBindingServices,
+        bool useSharedBindingOnInitialization = false)
     {
         this.connectedModeServices = connectedModeServices;
-        ViewModel = new ManageBindingViewModel(connectedModeServices, bindingController, solutionInfoProvider, new ProgressReporterViewModel());
+        this.useSharedBindingOnInitialization = useSharedBindingOnInitialization;
+        ViewModel = new ManageBindingViewModel(connectedModeServices, connectedModeBindingServices, new ProgressReporterViewModel());
         InitializeComponent();
     }
 
@@ -66,6 +69,10 @@ private void SelectProject_OnClick(object sender, RoutedEventArgs e)
     private async void ManageBindingDialog_OnInitialized(object sender, EventArgs e)
     {
         await ViewModel.InitializeDataAsync();
+        if (useSharedBindingOnInitialization)
+        {
+            await ViewModel.UseSharedBindingWithProgressAsync();
+        }
     }
 
     private void Unbind_OnClick(object sender, RoutedEventArgs e)
@@ -73,9 +80,9 @@ private void Unbind_OnClick(object sender, RoutedEventArgs e)
         ViewModel.Unbind();
     }
 
-    private void UseSharedBinding_OnClick(object sender, RoutedEventArgs e)
+    private async void UseSharedBinding_OnClick(object sender, RoutedEventArgs e)
     {
-        ViewModel.UseSharedBindingAsync().Forget();
+        await ViewModel.UseSharedBindingWithProgressAsync();
     }
 
     private void ExportBindingConfigurationButton_OnClick(object sender, RoutedEventArgs e)
diff --git a/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs b/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs
index 707d79542..52a84d70b 100644
--- a/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs
+++ b/src/ConnectedMode/UI/ManageBinding/ManageBindingViewModel.cs
@@ -19,10 +19,10 @@
  */
 
 using System.Collections.ObjectModel;
-using SonarLint.VisualStudio.ConnectedMode.Binding;
+using System.Windows;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.ConnectedMode.UI.ProjectSelection;
 using SonarLint.VisualStudio.ConnectedMode.UI.Resources;
-using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Core.Binding;
 using SonarLint.VisualStudio.Core.WPF;
 
@@ -34,10 +34,9 @@ public sealed class ManageBindingViewModel : ViewModelBase, IDisposable
     private ServerProject boundProject;
     private ConnectionInfo selectedConnectionInfo;
     private ServerProject selectedProject;
-    private bool isSharedBindingConfigurationDetected;
+    private SharedBindingConfigModel sharedBindingConfigModel;
     private readonly IConnectedModeServices connectedModeServices;
-    private readonly IBindingController bindingController;
-    private readonly ISolutionInfoProvider solutionInfoProvider;
+    private readonly IConnectedModeBindingServices connectedModeBindingServices;
     private readonly CancellationTokenSource cancellationTokenSource = new();
 
     public SolutionInfoModel SolutionInfo
@@ -62,6 +61,7 @@ public ServerProject BoundProject
             RaisePropertyChanged(nameof(IsSelectProjectButtonEnabled));
             RaisePropertyChanged(nameof(IsConnectionSelectionEnabled));
             RaisePropertyChanged(nameof(IsExportButtonEnabled));
+            RaisePropertyChanged(nameof(IsUseSharedBindingButtonVisible));
         }
     }
 
@@ -96,14 +96,13 @@ public ServerProject SelectedProject
         }
     }
 
-    public bool IsSharedBindingConfigurationDetected    
+    internal SharedBindingConfigModel SharedBindingConfigModel
     {
-        get => isSharedBindingConfigurationDetected;
+        get => sharedBindingConfigModel;
         set
         {
-            isSharedBindingConfigurationDetected = value;
-            RaisePropertyChanged();
-            RaisePropertyChanged(nameof(IsUseSharedBindingButtonEnabled));
+            sharedBindingConfigModel = value;
+            RaisePropertyChanged(nameof(IsUseSharedBindingButtonVisible));
         }
     }
 
@@ -115,28 +114,31 @@ public bool IsSharedBindingConfigurationDetected
     public bool IsSelectProjectButtonEnabled => IsConnectionSelected && !ProgressReporter.IsOperationInProgress && !IsCurrentProjectBound;
     public bool IsUnbindButtonEnabled => !ProgressReporter.IsOperationInProgress;
     public bool IsManageConnectionsButtonEnabled => !ProgressReporter.IsOperationInProgress;
-    public bool IsUseSharedBindingButtonEnabled => !ProgressReporter.IsOperationInProgress && IsSharedBindingConfigurationDetected;
+    public bool IsUseSharedBindingButtonEnabled => !ProgressReporter.IsOperationInProgress;
+    public bool IsUseSharedBindingButtonVisible => SharedBindingConfigModel != null && !IsCurrentProjectBound;
     public bool IsExportButtonEnabled => !ProgressReporter.IsOperationInProgress && IsCurrentProjectBound;
     public string ConnectionSelectionCaptionText => Connections.Any() ? UiResources.SelectConnectionToBindDescription : UiResources.NoConnectionExistsLabel;
 
      public ManageBindingViewModel(
-         IConnectedModeServices connectedModeServices,
-         IBindingController bindingController,
-         ISolutionInfoProvider solutionInfoProvider,
+         IConnectedModeServices connectedModeServices, 
+         IConnectedModeBindingServices connectedModeBindingServices,
          IProgressReporterViewModel progressReporterViewModel)
     {
         this.connectedModeServices = connectedModeServices;
-        this.bindingController = bindingController;
-        this.solutionInfoProvider = solutionInfoProvider;
+        this.connectedModeBindingServices = connectedModeBindingServices;
         ProgressReporter = progressReporterViewModel;
     }
     
     public async Task InitializeDataAsync()
     {
-        var loadData = new TaskToPerformParams<AdapterResponse>(LoadDataAsync, UiResources.LoadingConnectionsText, UiResources.LoadingConnectionsFailedText){AfterProgressUpdated = OnProgressUpdated};
+        var loadData = new TaskToPerformParams<AdapterResponse>(LoadDataAsync, UiResources.LoadingConnectionsText,
+                UiResources.LoadingConnectionsFailedText) { AfterProgressUpdated = OnProgressUpdated };
         await ProgressReporter.ExecuteTaskWithProgressAsync(loadData);
-        var displayBindStatus = new TaskToPerformParams<AdapterResponse>(DisplayBindStatusAsync, UiResources.FetchingBindingStatusText, UiResources.FetchingBindingStatusFailedText){AfterProgressUpdated = OnProgressUpdated};
+
+        var displayBindStatus = new TaskToPerformParams<AdapterResponse>(DisplayBindStatusAsync, UiResources.FetchingBindingStatusText,
+                UiResources.FetchingBindingStatusFailedText) { AfterProgressUpdated = OnProgressUpdated};
         await ProgressReporter.ExecuteTaskWithProgressAsync(displayBindStatus);
+        DetectSharedBinding();
     }
 
     public async Task BindWithProgressAsync()
@@ -145,6 +147,12 @@ public async Task BindWithProgressAsync()
         await ProgressReporter.ExecuteTaskWithProgressAsync(bind);
     }
 
+    public async Task UseSharedBindingWithProgressAsync()
+    {
+        var bind = new TaskToPerformParams<AdapterResponse>(UseSharedBindingAsync, UiResources.BindingInProgressText, UiResources.BindingFailedText) { AfterProgressUpdated = OnProgressUpdated };
+        await ProgressReporter.ExecuteTaskWithProgressAsync(bind);
+    }
+
     public void Unbind()
     {
         BoundProject = null;
@@ -152,14 +160,6 @@ public void Unbind()
         SelectedProject = null;
     }
 
-    public async Task UseSharedBindingAsync()
-    {
-        // this is only for demo purposes. It should be replaced with real SlCore binding logic
-        SelectedConnectionInfo = Connections.FirstOrDefault();
-        SelectedProject = new ServerProject("Myproj", "My proj");
-        await BindWithProgressAsync();
-    }
-
     public async Task ExportBindingConfigurationAsync()
     {
         try
@@ -174,6 +174,20 @@ public async Task ExportBindingConfigurationAsync()
         }
     }
 
+    internal async Task<AdapterResponse> UseSharedBindingAsync()
+    {
+        var connectionId = GetConnectionIdFromSharedBindingConfig();
+        if (!connectedModeServices.ServerConnectionsRepositoryAdapter.TryGetServerConnectionById(connectionId, out var serverConnection))
+        {
+            connectedModeServices.Logger.WriteLine(ConnectedMode.Resources.UseSharedBinding_ConnectionNotFound, connectionId);
+            connectedModeServices.MessageBox.Show(UiResources.NotFoundConnectionForSharedBindingMessageBoxText, UiResources.NotFoundConnectionForSharedBindingMessageBoxCaption, MessageBoxButton.OK, MessageBoxImage.Warning);
+            return new AdapterResponse(false);
+        }
+
+        var response = await BindAsync(serverConnection, SharedBindingConfigModel.ProjectKey);
+        return new AdapterResponse(response.Success);
+    }
+
     internal void UpdateProgress(string status)
     {
         ProgressReporter.ProgressStatus = status;
@@ -220,8 +234,8 @@ internal bool LoadConnections()
     
     internal /* for testing */ async Task<AdapterResponse> DisplayBindStatusAsync()
     {
-        var solutionName = await solutionInfoProvider.GetSolutionNameAsync();
-        var isFolderWorkspace = await solutionInfoProvider.IsFolderWorkspaceAsync();
+        var solutionName = await connectedModeBindingServices.SolutionInfoProvider.GetSolutionNameAsync();
+        var isFolderWorkspace = await connectedModeBindingServices.SolutionInfoProvider.IsFolderWorkspaceAsync();
         SolutionInfo = new SolutionInfoModel(solutionName, isFolderWorkspace ? SolutionType.Folder : SolutionType.Solution);
 
         var bindingConfiguration = connectedModeServices.ConfigurationProvider.GetConfiguration();
@@ -250,22 +264,39 @@ internal bool LoadConnections()
         {
             return new AdapterResponse(false);
         }
-        
+        return await BindAsync(serverConnection, SelectedProject?.Key);
+    }
+
+    private string GetConnectionIdFromSharedBindingConfig()
+    {
+        return SharedBindingConfigModel.IsSonarCloud() ? new ServerConnection.SonarCloud(SharedBindingConfigModel.Organization).Id : new ServerConnection.SonarQube(SharedBindingConfigModel.Uri).Id;
+    }
+
+    private async Task<AdapterResponse> BindAsync(ServerConnection serverConnection, string serverProjectKey)
+    {
         try
         {
-            var localBindingKey = await solutionInfoProvider.GetSolutionNameAsync();
-            var serverBindingKey = SelectedProject.Key;
-            var boundServerProject = new BoundServerProject(localBindingKey, serverBindingKey, serverConnection);
-            await bindingController.BindAsync(boundServerProject, cancellationTokenSource.Token);
+            var localBindingKey = await connectedModeBindingServices.SolutionInfoProvider.GetSolutionNameAsync();
+            var boundServerProject = new BoundServerProject(localBindingKey, serverProjectKey, serverConnection);
+            await connectedModeBindingServices.BindingController.BindAsync(boundServerProject, cancellationTokenSource.Token);
             return await DisplayBindStatusAsync();
         }
         catch (Exception ex)
         {
-            connectedModeServices.Logger.WriteLine($"{SonarLint.VisualStudio.ConnectedMode.Resources.Binding_Fails}", ex.Message);
+            connectedModeServices.Logger.WriteLine($"{ConnectedMode.Resources.Binding_Fails}", ex.Message);
             return new AdapterResponse(false);
         }
     }
 
+    internal void DetectSharedBinding()
+    {
+        if (IsCurrentProjectBound)
+        {
+            return;
+        }
+        SharedBindingConfigModel = connectedModeBindingServices.SharedBindingConfigProvider.GetSharedBinding();
+    }
+
     public void Dispose()
     {
         cancellationTokenSource?.Dispose();
diff --git a/src/ConnectedMode/UI/Resources/UiResources.Designer.cs b/src/ConnectedMode/UI/Resources/UiResources.Designer.cs
index 3f16f070f..e7eb4e420 100644
--- a/src/ConnectedMode/UI/Resources/UiResources.Designer.cs
+++ b/src/ConnectedMode/UI/Resources/UiResources.Designer.cs
@@ -600,6 +600,25 @@ public static string NoProjectsExistLabel {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Connection not found.
+        /// </summary>
+        public static string NotFoundConnectionForSharedBindingMessageBoxCaption {
+            get {
+                return ResourceManager.GetString("NotFoundConnectionForSharedBindingMessageBoxCaption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The shared binding could not be executed, because the connection to the server could not be found. 
+        ///Please manually add the connection through &quot;Manage Connections&quot; and then try again..
+        /// </summary>
+        public static string NotFoundConnectionForSharedBindingMessageBoxText {
+            get {
+                return ResourceManager.GetString("NotFoundConnectionForSharedBindingMessageBoxText", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to OK.
         /// </summary>
diff --git a/src/ConnectedMode/UI/Resources/UiResources.resx b/src/ConnectedMode/UI/Resources/UiResources.resx
index 32daeaab2..649867953 100644
--- a/src/ConnectedMode/UI/Resources/UiResources.resx
+++ b/src/ConnectedMode/UI/Resources/UiResources.resx
@@ -387,4 +387,11 @@
   <data name="LoadingProjectsFailedTextForNotFoundServerConnection" xml:space="preserve">
     <value>Server connection was not found. Projects could not be loaded.</value>
   </data>
+  <data name="NotFoundConnectionForSharedBindingMessageBoxText" xml:space="preserve">
+    <value>The shared binding could not be executed, because the connection to the server could not be found. 
+Please manually add the connection through "Manage Connections" and then try again.</value>
+  </data>
+  <data name="NotFoundConnectionForSharedBindingMessageBoxCaption" xml:space="preserve">
+    <value>Connection not found</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Integration.TeamExplorer.UnitTests/SectionControllerTests.cs b/src/Integration.TeamExplorer.UnitTests/SectionControllerTests.cs
index ac10b255e..c3bf99bcb 100644
--- a/src/Integration.TeamExplorer.UnitTests/SectionControllerTests.cs
+++ b/src/Integration.TeamExplorer.UnitTests/SectionControllerTests.cs
@@ -25,6 +25,8 @@
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using SonarLint.VisualStudio.ConnectedMode.Binding;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.Integration.Binding;
 using SonarLint.VisualStudio.Integration.TeamExplorer;
 using SonarLint.VisualStudio.Integration.WPF;
@@ -70,7 +72,9 @@ public void MefCtor_CheckIsExported()
                 MefTestHelpers.CreateExport<SVsServiceProvider>(),
                 MefTestHelpers.CreateExport<IHost>(new ConfigurableHost()),
                 MefTestHelpers.CreateExport<IWebBrowser>(),
-                MefTestHelpers.CreateExport<IAutoBindTrigger>());
+                MefTestHelpers.CreateExport<IAutoBindTrigger>(),
+                MefTestHelpers.CreateExport<ISharedBindingConfigProvider>(),
+                MefTestHelpers.CreateExport<ICredentialStoreService>());
         }
 
         [TestMethod]
@@ -475,7 +479,7 @@ public int QueryStatusReturnsResult
 
         private SectionController CreateTestSubject(IWebBrowser webBrowser = null)
         {
-            var controller = new SectionController(serviceProvider, host, webBrowser ?? new ConfigurableWebBrowser(), Mock.Of<IAutoBindTrigger>());
+            var controller = new SectionController(serviceProvider, host, webBrowser ?? new ConfigurableWebBrowser(), Mock.Of<IAutoBindTrigger>(), Mock.Of<ISharedBindingConfigProvider>(), Mock.Of<ICredentialStoreService>());
             controller.Initialize(null, new SectionInitializeEventArgs(new ServiceContainer(), null));
             return controller;
         }
diff --git a/src/Integration.TeamExplorer/SectionController.cs b/src/Integration.TeamExplorer/SectionController.cs
index ed3b51656..71c3b53ce 100644
--- a/src/Integration.TeamExplorer/SectionController.cs
+++ b/src/Integration.TeamExplorer/SectionController.cs
@@ -28,6 +28,7 @@
 using Microsoft.TeamFoundation.Controls.WPF.TeamExplorer;
 using Microsoft.VisualStudio.Shell;
 using SonarLint.VisualStudio.ConnectedMode.Binding;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.Integration.Binding;
 using SonarLint.VisualStudio.Integration.Connection;
 using SonarLint.VisualStudio.Integration.Progress;
@@ -55,18 +56,24 @@ internal class SectionController : TeamExplorerSectionBase, ISectionController
         private readonly IServiceProvider serviceProvider;
         private readonly IWebBrowser webBrowser;
         private readonly IAutoBindTrigger autoBindTrigger;
+        private readonly ISharedBindingConfigProvider sharedBindingConfigProvider;
+        private readonly ICredentialStoreService credentialStoreService;
 
         [ImportingConstructor]
         public SectionController(
             [Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
             IHost host,
             IWebBrowser webBrowser,
-            IAutoBindTrigger autoBindTrigger)
+            IAutoBindTrigger autoBindTrigger, 
+            ISharedBindingConfigProvider sharedBindingConfigProvider, 
+            ICredentialStoreService credentialStoreService)
         {
             this.serviceProvider = serviceProvider;
             this.Host = host;
             this.webBrowser = webBrowser;
             this.autoBindTrigger = autoBindTrigger;
+            this.sharedBindingConfigProvider = sharedBindingConfigProvider;
+            this.credentialStoreService = credentialStoreService;
         }
 
         internal /*for testing purposes*/ List<IVSOleCommandTarget> CommandTargets
@@ -238,7 +245,7 @@ private void InitializeControllerCommands()
         {
             // Due to complexity of connect and bind we "outsource" the controlling part
             // to separate controllers which just expose commands
-            var connectionController = new Connection.ConnectionController(serviceProvider, Host, autoBindTrigger);
+            var connectionController = new Connection.ConnectionController(serviceProvider, Host, autoBindTrigger, sharedBindingConfigProvider, credentialStoreService);
             var bindingController = new Binding.BindingController(serviceProvider, Host);
 
             this.CommandTargets.Add(connectionController);
diff --git a/src/Integration.UnitTests/Connection/ConnectControllerTests.cs b/src/Integration.UnitTests/Connection/ConnectControllerTests.cs
index 82e81f1bc..8039a66cc 100644
--- a/src/Integration.UnitTests/Connection/ConnectControllerTests.cs
+++ b/src/Integration.UnitTests/Connection/ConnectControllerTests.cs
@@ -25,6 +25,7 @@
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
+using SonarLint.VisualStudio.ConnectedMode.Binding;
 using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Integration.Binding;
@@ -48,6 +49,8 @@ public class ConnectControllerTests
         private ConfigurableSonarLintSettings settings;
         private Mock<ISolutionInfoProvider> solutionInfoProvider;
         private TestLogger logger;
+        private Mock<ISharedBindingConfigProvider> sharedBindingConfigProvider;
+        private Mock<ICredentialStoreService> credentialsStore;
 
         [TestInitialize]
         public void TestInit()
@@ -66,6 +69,8 @@ public void TestInit()
                 SonarQubeService = this.sonarQubeServiceMock.Object,
                 Logger = logger
             };
+            this.sharedBindingConfigProvider = new Mock<ISharedBindingConfigProvider>();
+            this.credentialsStore = new Mock<ICredentialStoreService>();
 
             IComponentModel componentModel = ConfigurableComponentModel.CreateWithExports(
                 new []
@@ -81,9 +86,9 @@ public void TestInit()
         [TestMethod]
         public void ConnectionController_Ctor_ArgumentChecks()
         {
-            Exceptions.Expect<ArgumentNullException>(() => new ConnectionController(null, Mock.Of<IHost>(), Mock.Of<IAutoBindTrigger>()));
-            Exceptions.Expect<ArgumentNullException>(() => new ConnectionController(Mock.Of<IServiceProvider>(), null, Mock.Of<IAutoBindTrigger>()));
-            Exceptions.Expect<ArgumentNullException>(() => new ConnectionController(Mock.Of<IServiceProvider>(), Mock.Of<IHost>(), null));
+            Exceptions.Expect<ArgumentNullException>(() => new ConnectionController(null, Mock.Of<IHost>(), Mock.Of<IAutoBindTrigger>(), sharedBindingConfigProvider.Object, credentialsStore.Object));
+            Exceptions.Expect<ArgumentNullException>(() => new ConnectionController(Mock.Of<IServiceProvider>(), null, Mock.Of<IAutoBindTrigger>(), sharedBindingConfigProvider.Object, credentialsStore.Object));
+            Exceptions.Expect<ArgumentNullException>(() => new ConnectionController(Mock.Of<IServiceProvider>(), Mock.Of<IHost>(), null, sharedBindingConfigProvider.Object, credentialsStore.Object));
         }
 
         [TestMethod]
@@ -184,7 +189,7 @@ public void ConnectionController_ConnectCommand_Execution()
             var connectionWorkflowMock = CreateWorkflow();
             connectionWorkflowMock.Setup(x => x.EstablishConnection(It.IsAny<ConnectionInformation>(), It.IsAny<string>()));
             ConnectionController testSubject = new ConnectionController(this.serviceProvider, this.host, null,
-                this.connectionProvider, connectionWorkflowMock.Object);
+                this.connectionProvider, connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
             this.solutionInfoProvider.Setup(x => x.IsSolutionFullyOpened()).Returns(true);
 
             // Case 1: connection provider return null connection
@@ -232,9 +237,11 @@ public void ConnectionController_ConnectCommand_SharedConfigAndCredentialsPresen
             SetUpOpenSolution();
             var connectionProviderMock = new Mock<IConnectionInformationProvider>();
             var testSubject = new ConnectionController(this.serviceProvider, this.host, null, connectionProviderMock.Object,
-                connectionWorkflowMock.Object);
-            host.SharedBindingConfig = new SharedBindingConfigModel { ProjectKey = "projectKey", Uri = new Uri("https://sonarcloudi.io"), Organization = "Org"};
-            host.CredentialsForSharedConfig = new Credential("user", "pwd");
+                connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
+            var sharedBindingConfig = new SharedBindingConfigModel { ProjectKey = "projectKey", Uri = new Uri("https://sonarcloud.io"), Organization = "Org" };
+            sharedBindingConfigProvider.Setup(mock => mock.GetSharedBinding()).Returns(sharedBindingConfig);
+            credentialsStore.Setup(mock => mock.ReadCredentials(It.IsAny<TargetUri>())).Returns(new Credential("user", "pwd"));
+            
             
             testSubject.ConnectCommand.Execute(new ConnectConfiguration(){UseSharedBinding = true});
             
@@ -253,12 +260,13 @@ public void ConnectionController_ConnectCommand_SharedConfig_AsksForCredentialsP
             SetUpOpenSolution();
             var connectionProviderMock = new Mock<IConnectionInformationProvider>();
             var testSubject = new ConnectionController(this.serviceProvider, this.host, null, connectionProviderMock.Object,
-                connectionWorkflowMock.Object);
-            host.SharedBindingConfig = new SharedBindingConfigModel { ProjectKey = "projectKey", Uri = new Uri("https://sonarcloudi.io"), Organization = "Org"};
+                connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
+            var sharedBindingConfig = new SharedBindingConfigModel { ProjectKey = "projectKey", Uri = new Uri("https://sonarcloud.io"), Organization = "Org" };
+            sharedBindingConfigProvider.Setup(mock => mock.GetSharedBinding()).Returns(sharedBindingConfig);
             var connectionInformation =
-                new ConnectionInformation(host.SharedBindingConfig.Uri, "user", "pwd".ToSecureString())
+                new ConnectionInformation(sharedBindingConfig.Uri, "user", "pwd".ToSecureString())
                 {
-                    Organization = new SonarQubeOrganization(host.SharedBindingConfig.Organization, string.Empty)
+                    Organization = new SonarQubeOrganization(sharedBindingConfig.Organization, string.Empty)
                 };
             SetupConnectionProvider(connectionProviderMock, connectionInformation);
             
@@ -269,7 +277,7 @@ public void ConnectionController_ConnectCommand_SharedConfig_AsksForCredentialsP
                 Times.Once);
             connectionProviderMock.Verify(x => 
                     x.GetConnectionInformation(It.Is<ConnectionInformation>(c => 
-                        c.ServerUri == host.SharedBindingConfig.Uri && c.Organization.Key == host.SharedBindingConfig.Organization)),
+                        c.ServerUri == sharedBindingConfig.Uri && c.Organization.Key == sharedBindingConfig.Organization)),
                 Times.Once);
         }
 
@@ -291,14 +299,14 @@ private void TestDisabledSharedConfig(ConnectConfiguration config)
             SetupConnectionWorkflow(connectionWorkflowMock);
             SetUpOpenSolution();
             var connectionProviderMock = new Mock<IConnectionInformationProvider>();
-            host.SharedBindingConfig = new SharedBindingConfigModel
-                { ProjectKey = "projectKey", Uri = new Uri("https://sonarcloudi.io"), Organization = "Org" };
-            host.CredentialsForSharedConfig = new Credential("user", "pwd");
+            var sharedBindingConfig = new SharedBindingConfigModel { ProjectKey = "projectKey", Uri = new Uri("https://sonarcloud.io"), Organization = "Org" };
+            sharedBindingConfigProvider.Setup(mock => mock.GetSharedBinding()).Returns(sharedBindingConfig);
+            credentialsStore.Setup(mock => mock.ReadCredentials(It.IsAny<TargetUri>())).Returns(new Credential("user", "pwd"));
             var expectedConnection = new ConnectionInformation(new Uri("https://127.0.0.0"));
             SetupConnectionProvider(connectionProviderMock, expectedConnection);
 
             var testSubject = new ConnectionController(this.serviceProvider, this.host, null,
-                connectionProviderMock.Object, connectionWorkflowMock.Object);
+                connectionProviderMock.Object, connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
 
             testSubject.ConnectCommand.Execute(config);
 
@@ -321,7 +329,7 @@ public void ConnectionController_ConnectCommand_SharedConfigNotPresentDoesNotAut
             SetupConnectionProvider(connectionProviderMock, expectedConnection);
             
             var testSubject = new ConnectionController(this.serviceProvider, this.host, null,
-                connectionProviderMock.Object, connectionWorkflowMock.Object);
+                connectionProviderMock.Object, connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
             
             testSubject.ConnectCommand.Execute(new ConnectConfiguration() { UseSharedBinding = true });
             
@@ -381,7 +389,7 @@ public void ConnectionController_RefreshCommand_Execution()
             // Arrange
             var connectionWorkflowMock = CreateWorkflow();
             ConnectionController testSubject = new ConnectionController(serviceProvider, host, null, connectionProvider,
-                connectionWorkflowMock.Object);
+                connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
             this.connectionProvider.ConnectionInformationToReturn = new ConnectionInformation(new Uri("http://notExpected"));
             var connection = new ConnectionInformation(new Uri("http://Expected"));
             // Sanity
@@ -405,7 +413,7 @@ public void ConnectionController_SetConnectionInProgress()
             // Arrange
             var connectionWorkflowMock = CreateWorkflow();
             ConnectionController testSubject = new ConnectionController(serviceProvider, host, null, connectionProvider,
-                connectionWorkflowMock.Object);
+                connectionWorkflowMock.Object, sharedBindingConfigProvider.Object, credentialsStore.Object);
             this.solutionInfoProvider.Setup(x => x.IsSolutionFullyOpened()).Returns(true);
             this.connectionProvider.ConnectionInformationToReturn = null;
             var progressEvents = new ConfigurableProgressEvents();
@@ -463,6 +471,6 @@ private static void SetupConnectionProvider(Mock<IConnectionInformationProvider>
         }
         
         private ConnectionController CreateTestSubject() =>
-            new ConnectionController(serviceProvider, host, Mock.Of<IAutoBindTrigger>());
+            new ConnectionController(serviceProvider, host, Mock.Of<IAutoBindTrigger>(), sharedBindingConfigProvider.Object, credentialsStore.Object);
     }
 }
diff --git a/src/Integration.UnitTests/MefServices/SharedBindingSuggestionServiceTests.cs b/src/Integration.UnitTests/MefServices/SharedBindingSuggestionServiceTests.cs
index d7f9573e5..e418188a3 100644
--- a/src/Integration.UnitTests/MefServices/SharedBindingSuggestionServiceTests.cs
+++ b/src/Integration.UnitTests/MefServices/SharedBindingSuggestionServiceTests.cs
@@ -18,15 +18,12 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-using System;
-using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using Moq;
 using SonarLint.VisualStudio.ConnectedMode.Binding.Suggestion;
-using SonarLint.VisualStudio.Integration.Connection;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
+using SonarLint.VisualStudio.ConnectedMode.UI;
+using SonarLint.VisualStudio.Core;
+using SonarLint.VisualStudio.Core.Binding;
 using SonarLint.VisualStudio.Integration.MefServices;
-using SonarLint.VisualStudio.Integration.TeamExplorer;
-using SonarLint.VisualStudio.Integration.WPF;
 using SonarLint.VisualStudio.TestInfrastructure;
 using SonarQube.Client;
 
@@ -35,13 +32,31 @@ namespace SonarLint.VisualStudio.Integration.UnitTests.MefServices;
 [TestClass]
 public class SharedBindingSuggestionServiceTests
 {
+    private SharedBindingSuggestionService testSubject;
+    private ISuggestSharedBindingGoldBar suggestSharedBindingGoldBar;
+    private IConnectedModeServices connectedModeServices;
+    private IConnectedModeBindingServices connectedModeBindingServices;
+    private IActiveSolutionTracker activeSolutionTracker;
+
+    [TestInitialize]
+    public void TestInitialize()
+    {
+        suggestSharedBindingGoldBar = Substitute.For<ISuggestSharedBindingGoldBar>();
+        connectedModeServices = Substitute.For<IConnectedModeServices>();
+        connectedModeBindingServices = Substitute.For<IConnectedModeBindingServices>();
+        activeSolutionTracker = Substitute.For<IActiveSolutionTracker>();
+
+        testSubject = new SharedBindingSuggestionService(suggestSharedBindingGoldBar, connectedModeServices, connectedModeBindingServices, activeSolutionTracker);
+    }
+
     [TestMethod]
     public void MefCtor_CheckExports()
     {
         MefTestHelpers.CheckTypeCanBeImported<SharedBindingSuggestionService, ISharedBindingSuggestionService>(
             MefTestHelpers.CreateExport<ISuggestSharedBindingGoldBar>(),
-            MefTestHelpers.CreateExport<ITeamExplorerController>(),
-            MefTestHelpers.CreateExport<IConnectedModeWindowEventBasedScheduler>());
+            MefTestHelpers.CreateExport<IConnectedModeServices>(),
+            MefTestHelpers.CreateExport<IConnectedModeBindingServices>(),
+            MefTestHelpers.CreateExport<IActiveSolutionTracker>());
     }
 
     [TestMethod]
@@ -51,97 +66,82 @@ public void MefCtor_CheckIsSingleton()
     }
 
     [TestMethod]
-    public void ConnectAfterTeamExplorerInitialized_ConnectedModeWindowLoaded_NotLoaded_ConnectScheduledForLater()
+    public void Suggest_SharedBindingExistsAndIsStandalone_ShowsGoldBar()
     {
-        var testSubject = CreateTestSubject(out var bindingGoldBar, out var teamExplorerController, out var scheduler);
-        testSubject.Suggest(ServerType.SonarQube, () => null);
-
-        var callSequence = new MockSequence();
+        MockSharedBindingConfigExists();
+        MockSolutionMode(SonarLintMode.Standalone);
 
-        scheduler.InSequence(callSequence).Setup(x => x.ScheduleActionOnNextEvent(It.IsAny<Action>()));
-        teamExplorerController.InSequence(callSequence).Setup(x => x.ShowSonarQubePage());
-        
-        CallConnectHandler(bindingGoldBar);
+        testSubject.Suggest();
         
-        scheduler.Verify(x => x.ScheduleActionOnNextEvent(It.IsAny<Action>()), Times.Once);
-        scheduler.VerifyNoOtherCalls();
-        teamExplorerController.Verify(x => x.ShowSonarQubePage(), Times.Once);
-        teamExplorerController.VerifyNoOtherCalls();
+        suggestSharedBindingGoldBar.Received(1).Show(ServerType.SonarQube, Arg.Any<Action>());
     }
 
     [TestMethod]
-    public void ConnectAfterTeamExplorerInitialized_ConnectedModeWindowLoaded_CallsConnectCommand()
+    public void Suggest_SharedBindingExistsAndIsConnected_DoesNotShowGoldBar()
     {
-        var testSubject = CreateTestSubject(out var bindingGoldBar, out var teamExplorerController, out var scheduler);
-        testSubject.Suggest(ServerType.SonarQube, CreateConnectCommandProvider(out var connectCommand));
+        MockSharedBindingConfigExists();
+        MockSolutionMode(SonarLintMode.Connected);
 
-        var callSequence = new MockSequence();
+        testSubject.Suggest();
 
-        teamExplorerController.InSequence(callSequence).Setup(x => x.ShowSonarQubePage());
-        connectCommand.InSequence(callSequence)
-            .Setup(x => x.CanExecute(testSubject.autobindEnabledConfiguration))
-            .Returns(true);
-        connectCommand.InSequence(callSequence)
-            .Setup(x => x.Execute(testSubject.autobindEnabledConfiguration));
-        
-        CallConnectHandler(bindingGoldBar);
-        
-        scheduler.VerifyNoOtherCalls();
-        teamExplorerController.Verify(x => x.ShowSonarQubePage(), Times.Once);
-        teamExplorerController.VerifyNoOtherCalls();
-        connectCommand.Verify(x => x.CanExecute(testSubject.autobindEnabledConfiguration), Times.Once);
-        connectCommand.Verify(x => x.Execute(testSubject.autobindEnabledConfiguration), Times.Once);
-        connectCommand.VerifyNoOtherCalls();
+        suggestSharedBindingGoldBar.DidNotReceive().Show(ServerType.SonarQube, Arg.Any<Action>());
     }
 
     [TestMethod]
-    public void Suggest_HasServerType_ShowsGoldBar()
+    public void Suggest_SharedBindingDoesNotExistAndIsStandAlone_DoesNotShowGoldBar()
     {
-        var testSubject = CreateTestSubject(out var bindingGoldBar, out _, out _);
-        
-        testSubject.Suggest(ServerType.SonarQube, CreateConnectCommandProvider(out _));
-        
-        bindingGoldBar.Verify(x => x.Show(ServerType.SonarQube, It.IsAny<Action>()), Times.Once);
+        MockSolutionMode(SonarLintMode.Standalone);
+
+        testSubject.Suggest();
+
+        suggestSharedBindingGoldBar.DidNotReceive().Show(ServerType.SonarQube, Arg.Any<Action>());
     }
 
     [TestMethod]
-    public void Suggest_NoServerType_DoesNotCallGoldBar()
+    public void ActiveSolutionChanged_SolutionIsOpened_ShowsGoldBar()
     {
-        var testSubject = CreateTestSubject(out var bindingGoldBar, out _, out _);
+        MockSharedBindingConfigExists();
+        MockSolutionMode(SonarLintMode.Standalone);
         
-        testSubject.Suggest(null, CreateConnectCommandProvider(out _));
-        
-        bindingGoldBar.Verify(x => x.Show(It.IsAny<ServerType>(), It.IsAny<Action>()), Times.Never);
+        RaiseActiveSolutionChanged(true);
+
+        suggestSharedBindingGoldBar.Received(1).Show(ServerType.SonarQube, Arg.Any<Action>());
     }
 
     [TestMethod]
-    public void Close_ClosesGoldBar()
+    public void ActiveSolutionChanged_SolutionIsOpened_DoesNotShowGoldBar()
     {
-        var testSubject = CreateTestSubject(out var bindingGoldBar, out _, out _);
+        MockSharedBindingConfigExists();
+        MockSolutionMode(SonarLintMode.Standalone);
         
-        testSubject.Close();
+        RaiseActiveSolutionChanged(false);
+
+        suggestSharedBindingGoldBar.DidNotReceive().Show(ServerType.SonarQube, Arg.Any<Action>());
+    }
+
+    [TestMethod]
+    public void Dispose_UnsubscribesFromActiveSolutionChanged()
+    {
+        testSubject.Dispose();
 
-        bindingGoldBar.Verify(x => x.Close());
+        activeSolutionTracker.Received(1).ActiveSolutionChanged -= Arg.Any<EventHandler<ActiveSolutionChangedEventArgs>>();
     }
 
-    private void CallConnectHandler(Mock<ISuggestSharedBindingGoldBar> mock)
+    private void RaiseActiveSolutionChanged(bool isSolutionOpened)
     {
-        ((Action)mock.Invocations.Single().Arguments[1])();
+        activeSolutionTracker.ActiveSolutionChanged += Raise.EventWith(new ActiveSolutionChangedEventArgs(isSolutionOpened));
     }
-    
-    private Func<ICommand<ConnectConfiguration>> CreateConnectCommandProvider(out Mock<ICommand<ConnectConfiguration>> connectCommandMock)
+
+    private void MockSolutionMode(SonarLintMode mode)
     {
-        var commandMock = new Mock<ICommand<ConnectConfiguration>>();
-        connectCommandMock = commandMock;
-        return () => commandMock.Object;
+        connectedModeServices.ConfigurationProvider.GetConfiguration().Returns(new BindingConfiguration(null, mode, string.Empty));
     }
-    
-    private SharedBindingSuggestionService CreateTestSubject(out Mock<ISuggestSharedBindingGoldBar> bindingGoldBar, 
-        out Mock<ITeamExplorerController> teamExplorerController,
-        out Mock<IConnectedModeWindowEventBasedScheduler> connectedModeWindowEventBasedScheduler)
+
+    private void MockSharedBindingConfigExists()
     {
-        return new SharedBindingSuggestionService((bindingGoldBar = new Mock<ISuggestSharedBindingGoldBar>()).Object,
-            (teamExplorerController = new Mock<ITeamExplorerController>()).Object,
-            (connectedModeWindowEventBasedScheduler = new Mock<IConnectedModeWindowEventBasedScheduler>()).Object);
+        connectedModeBindingServices.SharedBindingConfigProvider.GetSharedBinding().Returns(new SharedBindingConfigModel());
     }
+
+
+
 }
diff --git a/src/Integration.UnitTests/MefServices/VsSessionHostTests.cs b/src/Integration.UnitTests/MefServices/VsSessionHostTests.cs
index cca5c8312..173acfe74 100644
--- a/src/Integration.UnitTests/MefServices/VsSessionHostTests.cs
+++ b/src/Integration.UnitTests/MefServices/VsSessionHostTests.cs
@@ -18,16 +18,10 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-using System;
-using FluentAssertions;
-using Microsoft.Alm.Authentication;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 using SonarLint.VisualStudio.ConnectedMode.Binding;
-using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Core.Binding;
-using SonarLint.VisualStudio.Integration.Connection;
 using SonarLint.VisualStudio.Integration.MefServices;
 using SonarLint.VisualStudio.Integration.TeamExplorer;
 using SonarLint.VisualStudio.Integration.WPF;
@@ -44,8 +38,6 @@ public class VsSessionHostTests
         private ConfigurableStateManager stateManager;
         private ConfigurableProgressStepRunner stepRunner;
         private ConfigurableConfigurationProvider configProvider;
-        private Mock<ISharedBindingConfigProvider> sharedBindingConfigProviderMock;
-        private Mock<ICredentialStoreService> credentialStoreServiceMock;
         private Mock<ISharedBindingSuggestionService> sharedBindingSuggestionService;
         private Mock<IConnectedModeWindowEventListener> connectedModeWindowEventListener;
 
@@ -57,8 +49,6 @@ public void TestInitialize()
             this.sonarQubeServiceMock = new Mock<ISonarQubeService>();
             this.stepRunner = new ConfigurableProgressStepRunner();
             this.configProvider = new ConfigurableConfigurationProvider();
-            sharedBindingConfigProviderMock = new Mock<ISharedBindingConfigProvider>();
-            credentialStoreServiceMock = new Mock<ICredentialStoreService>();
             sharedBindingSuggestionService = new Mock<ISharedBindingSuggestionService>();
             connectedModeWindowEventListener = new Mock<IConnectedModeWindowEventListener>();
         }
@@ -72,9 +62,6 @@ public void MefCtor_CheckIsExported()
                 MefTestHelpers.CreateExport<ISonarQubeService>(),
                 MefTestHelpers.CreateExport<IActiveSolutionTracker>(),
                 MefTestHelpers.CreateExport<IConfigurationProvider>(),
-                MefTestHelpers.CreateExport<ISharedBindingConfigProvider>(),
-                MefTestHelpers.CreateExport<ICredentialStoreService>(),
-                MefTestHelpers.CreateExport<ISharedBindingSuggestionService>(),
                 MefTestHelpers.CreateExport<IConnectedModeWindowEventListener>(),
                 MefTestHelpers.CreateExport<ILogger>());
         }
@@ -100,7 +87,6 @@ public void Dispose_UnsubscribesFromActiveSolutionChanged()
 
             trackerMock.VerifyRemove(x => x.ActiveSolutionChanged -= It.IsAny<EventHandler<ActiveSolutionChangedEventArgs>>(), Times.Once);
             connectedModeWindowEventListener.Verify(x => x.Dispose(), Times.Once);
-            sharedBindingSuggestionService.Verify(x => x.Close(), Times.Once);
         }
 
         [TestMethod]
@@ -367,127 +353,6 @@ public void VsSessionHost_ResetBinding_ErrorInReadingBinding()
             this.stateManager.AssignedProjectKey.Should().BeNull();
         }
 
-        [TestMethod]
-        public void ResetBinding_SharedConfigSetWhenUnbound()
-        {
-            var tracker = new ConfigurableActiveSolutionTracker();
-            var testSubject = CreateTestSubject(tracker);
-            var sharedBindingConfig = new SharedBindingConfigModel { ProjectKey = "abcd" };
-            sharedBindingConfigProviderMock.Setup(x => x.GetSharedBinding())
-                .Returns(sharedBindingConfig);
-            
-            tracker.SimulateActiveSolutionChanged(isSolutionOpen: true);
-            
-            testSubject.SharedBindingConfig.Should().BeSameAs(sharedBindingConfig);
-            testSubject.VisualStateManager.HasSharedBinding.Should().BeTrue();
-            CheckSuggestionShowCalledTimes(1);
-            CheckResetConnectionCalledTimes(testSubject, 1);
-        }
-        
-        [TestMethod]
-        public void ResetBinding_SharedConfigNotSetWhenNull()
-        {
-            var tracker = new ConfigurableActiveSolutionTracker();
-            var testSubject = CreateTestSubject(tracker);
-            sharedBindingSuggestionService.Invocations.Clear();
-            sharedBindingConfigProviderMock.Setup(x => x.GetSharedBinding())
-                .Returns((SharedBindingConfigModel)null);
-            
-            tracker.SimulateActiveSolutionChanged(isSolutionOpen: true);
-            
-            testSubject.SharedBindingConfig.Should().BeNull();
-            testSubject.VisualStateManager.HasSharedBinding.Should().BeFalse();
-            CheckSuggestionShowCalledTimes(1, serverType: null);
-            CheckResetConnectionCalledTimes(testSubject, 1);
-        }
-
-        [TestMethod]
-        public void ResetBinding_ClosedSolution_DoesNotSuggestSharedBinding()
-        {
-            var tracker = new ConfigurableActiveSolutionTracker();
-            var testSubject = CreateTestSubject(tracker);
-            sharedBindingSuggestionService.Invocations.Clear();
-            sharedBindingConfigProviderMock.Setup(x => x.GetSharedBinding())
-                .Returns((SharedBindingConfigModel)null);
-            
-            tracker.SimulateActiveSolutionChanged(isSolutionOpen: false);
-            
-            testSubject.SharedBindingConfig.Should().BeNull();
-            testSubject.VisualStateManager.HasSharedBinding.Should().BeFalse();
-            CheckSuggestionClosed();
-            CheckSuggestionShowCalledTimes(0);
-            CheckResetConnectionCalledTimes(testSubject, 0);
-        }
-        
-        [TestMethod]
-        public void InitializeBinding_SharedConfigSetWhenUnbound()
-        {
-            var testSubject = CreateTestSubject();
-            var section = ConfigurableSectionController.CreateDefault();
-            sharedBindingConfigProviderMock.Setup(x => x.GetSharedBinding())
-                .Returns(new SharedBindingConfigModel { ProjectKey = "abcd" });
-            
-            testSubject.SetActiveSection(section);
-            
-            testSubject.SharedBindingConfig.Should().NotBeNull();
-            testSubject.VisualStateManager.HasSharedBinding.Should().BeTrue();
-            CheckSuggestionShowCalledTimes(1);
-            CheckResetConnectionCalledTimes(testSubject, 1);
-        }
-
-        [TestMethod]
-        public void ResetBinding_SharedConfigRemovedWhenBound()
-        {
-            var tracker = new ConfigurableActiveSolutionTracker();
-            var testSubject = CreateTestSubject(tracker);
-            var section = ConfigurableSectionController.CreateDefault();
-            sharedBindingConfigProviderMock.Setup(x => x.GetSharedBinding())
-                .Returns(new SharedBindingConfigModel { ProjectKey = "abcd" });
-            testSubject.SetActiveSection(section);
-            ((ConfigurableStateManager)testSubject.VisualStateManager).ResetConnectionConfigCalled = 0;
-
-            testSubject.SharedBindingConfig.Should().NotBeNull();
-            sharedBindingSuggestionService.Invocations.Clear();
-            
-            this.stateManager.SetBoundProject(new Uri("http://bound"), null, "bla");
-            SetConfiguration(new BoundServerProject("solution", "bla", new ServerConnection.SonarQube(new Uri("http://bound"))), SonarLintMode.Connected);
-            
-            tracker.SimulateActiveSolutionChanged(isSolutionOpen: true);
-
-            testSubject.SharedBindingConfig.Should().BeNull();
-            this.stateManager.BoundProjectKey.Should().Be("bla");
-            CheckSuggestionShowCalledTimes(0);
-            CheckResetConnectionCalledTimes(testSubject, 0);
-        }
-
-        [DataRow(null)]
-        [DataRow("http://localhost:9000")]
-        [DataRow("https://sonarqube.io")]
-        [DataTestMethod]
-        public void GetCredentialsForSharedConfig_CallsCredentialServiceOnlyWhenSharedConfigExists(string serverUri)
-        {
-            var testSubject = CreateTestSubject();
-            var section = ConfigurableSectionController.CreateDefault();
-            sharedBindingConfigProviderMock.Setup(x => x.GetSharedBinding())
-                .Returns(serverUri != null ? new SharedBindingConfigModel { Uri = new Uri(serverUri)} : null);
-            testSubject.SetActiveSection(section);
-            var credential = new Credential("a");
-            credentialStoreServiceMock.Setup(x => x.ReadCredentials(It.IsAny<TargetUri>())).Returns(credential);
-
-            var result = testSubject.GetCredentialsForSharedConfig();
-            
-            if (serverUri == null)
-            {
-                credentialStoreServiceMock.Verify(x => x.ReadCredentials(It.IsAny<TargetUri>()), Times.Never);
-                result.Should().BeNull();
-            }
-            else
-            {
-                credentialStoreServiceMock.Verify(x => x.ReadCredentials(It.IsAny<TargetUri>()), Times.Once);
-                result.Should().BeSameAs(credential);
-            }
-        }
-
         #endregion Tests
 
         #region Helpers
@@ -500,10 +365,7 @@ private VsSessionHost CreateTestSubject(IActiveSolutionTracker tracker = null)
                 this.sonarQubeServiceMock.Object,
                 tracker ?? new ConfigurableActiveSolutionTracker(),
                 this.configProvider,
-                sharedBindingConfigProviderMock.Object,
-                credentialStoreServiceMock.Object,
                 connectedModeWindowEventListener.Object,
-                sharedBindingSuggestionService.Object,
                 Mock.Of<ILogger>());
 
             this.stateManager.Host = host;
@@ -517,24 +379,6 @@ private void SetConfiguration(BoundServerProject project, SonarLintMode mode)
             this.configProvider.ModeToReturn = mode;
             this.configProvider.FolderPathToReturn = "c:\\test\\";
         }
-        
-        private static void CheckResetConnectionCalledTimes(VsSessionHost testSubject, int count)
-        {
-            ((ConfigurableStateManager)testSubject.VisualStateManager).ResetConnectionConfigCalled.Should().Be(count);
-        }
-        
-        private void CheckSuggestionShowCalledTimes(int count, ServerType? serverType = ServerType.SonarQube)
-        {
-            sharedBindingSuggestionService.Verify(x => x.Suggest(serverType ?? It.IsAny<ServerType?>(),
-                    It.IsAny<Func<ICommand<ConnectConfiguration>>>()),
-                Times.Exactly(count));
-            sharedBindingSuggestionService.VerifyNoOtherCalls();
-        }
-
-        private void CheckSuggestionClosed()
-        {
-            sharedBindingSuggestionService.Verify(x => x.Close());
-        }
 
         #endregion Helpers
     }
diff --git a/src/Integration.Vsix.UnitTests/Commands/PackageCommandManagerTests.cs b/src/Integration.Vsix.UnitTests/Commands/PackageCommandManagerTests.cs
index 1834da2db..7a23dcabc 100644
--- a/src/Integration.Vsix.UnitTests/Commands/PackageCommandManagerTests.cs
+++ b/src/Integration.Vsix.UnitTests/Commands/PackageCommandManagerTests.cs
@@ -59,8 +59,7 @@ public void PackageCommandManager_Initialize()
                 Mock.Of<IBrowserService>(),
                 Mock.Of<PackageCommandManager.ShowOptionsPage>(),
                 Mock.Of<IConnectedModeServices>(),
-                Mock.Of<ISolutionInfoProvider>(),
-                Mock.Of<IBindingController>());
+Mock.Of<IConnectedModeBindingServices>());
 
             // Assert
             menuService.Commands.Should().HaveCountGreaterOrEqualTo(allCommands.Count, "Unexpected number of commands");
diff --git a/src/Integration.Vsix/Commands/ConnectedModeMenu/NewConnectedModeCommand.cs b/src/Integration.Vsix/Commands/ConnectedModeMenu/NewConnectedModeCommand.cs
index 8368691ea..8e4836b92 100644
--- a/src/Integration.Vsix/Commands/ConnectedModeMenu/NewConnectedModeCommand.cs
+++ b/src/Integration.Vsix/Commands/ConnectedModeMenu/NewConnectedModeCommand.cs
@@ -19,10 +19,8 @@
  */
 
 using System.Windows;
-using SonarLint.VisualStudio.ConnectedMode.Binding;
 using SonarLint.VisualStudio.ConnectedMode.UI.ManageBinding;
 using SonarLint.VisualStudio.ConnectedMode.UI;
-using SonarLint.VisualStudio.Core;
 
 namespace SonarLint.VisualStudio.Integration.Vsix.Commands.ConnectedModeMenu
 {
@@ -30,20 +28,18 @@ namespace SonarLint.VisualStudio.Integration.Vsix.Commands.ConnectedModeMenu
     public class NewConnectedModeCommand : VsCommandBase
     {
         private readonly IConnectedModeServices connectedModeServices;
-        private readonly IBindingController bindingController;
-        private readonly ISolutionInfoProvider solutionInfoProvider;
+        private readonly IConnectedModeBindingServices connectedModeBindingServices;
         internal const int Id = 0x104;
 
-        public NewConnectedModeCommand(IConnectedModeServices connectedModeServices, IBindingController bindingController, ISolutionInfoProvider solutionInfoProvider)
+        public NewConnectedModeCommand(IConnectedModeServices connectedModeServices, IConnectedModeBindingServices connectedModeBindingServices)
         {
             this.connectedModeServices = connectedModeServices;
-            this.bindingController = bindingController;
-            this.solutionInfoProvider = solutionInfoProvider;
+            this.connectedModeBindingServices = connectedModeBindingServices;
         }
 
         protected override void InvokeInternal()
         {
-           new ManageBindingDialog(connectedModeServices, bindingController, solutionInfoProvider).ShowDialog(Application.Current.MainWindow);
+           new ManageBindingDialog(connectedModeServices, connectedModeBindingServices).ShowDialog(Application.Current.MainWindow);
         }
     }
 }
diff --git a/src/Integration.Vsix/Commands/PackageCommandManager.cs b/src/Integration.Vsix/Commands/PackageCommandManager.cs
index 055a6c48d..d45d2c22c 100644
--- a/src/Integration.Vsix/Commands/PackageCommandManager.cs
+++ b/src/Integration.Vsix/Commands/PackageCommandManager.cs
@@ -49,8 +49,7 @@ public void Initialize(ITeamExplorerController teamExplorerController,
             IBrowserService browserService,
             ShowOptionsPage showOptionsPage,
             IConnectedModeServices connectedModeServices,
-            ISolutionInfoProvider solutionInfoProvider,
-            IBindingController bindingController)
+            IConnectedModeBindingServices connectedModeBindingServices)
         {
             RegisterCommand((int)PackageCommandId.ProjectExcludePropertyToggle, new ProjectExcludePropertyToggleCommand(projectPropertyManager));
             RegisterCommand((int)PackageCommandId.ProjectTestPropertyAuto, new ProjectTestPropertySetCommand(projectPropertyManager, null));
@@ -71,8 +70,8 @@ public void Initialize(ITeamExplorerController teamExplorerController,
 
             // Connected mode buttons
             RegisterCommand(CommonGuids.ConnectedModeMenuCommandSet, ManageConnectionsCommand.Id, new ManageConnectionsCommand(teamExplorerController));
-            RegisterCommand(CommonGuids.ConnectedModeMenuCommandSet, NewConnectedModeCommand.Id, new NewConnectedModeCommand(connectedModeServices, bindingController, solutionInfoProvider));
-            RegisterCommand(CommonGuids.ConnectedModeMenuCommandSet, SaveSharedConnectionCommand.Id, new SaveSharedConnectionCommand(connectedModeServices.ConfigurationProvider, connectedModeServices.SharedBindingConfigProvider));
+            RegisterCommand(CommonGuids.ConnectedModeMenuCommandSet, NewConnectedModeCommand.Id, new NewConnectedModeCommand(connectedModeServices, connectedModeBindingServices));
+            RegisterCommand(CommonGuids.ConnectedModeMenuCommandSet, SaveSharedConnectionCommand.Id, new SaveSharedConnectionCommand(connectedModeServices.ConfigurationProvider, connectedModeBindingServices.SharedBindingConfigProvider));
         }
 
         internal /* testing purposes */ OleMenuCommand RegisterCommand(int commandId, VsCommandBase command)
diff --git a/src/Integration.Vsix/SonarLintIntegrationPackage.cs b/src/Integration.Vsix/SonarLintIntegrationPackage.cs
index c49942e80..26d073406 100644
--- a/src/Integration.Vsix/SonarLintIntegrationPackage.cs
+++ b/src/Integration.Vsix/SonarLintIntegrationPackage.cs
@@ -22,10 +22,11 @@
 using System.Runtime.InteropServices;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Threading;
-using SonarLint.VisualStudio.ConnectedMode.Binding;
+using SonarLint.VisualStudio.ConnectedMode.Binding.Suggestion;
 using SonarLint.VisualStudio.ConnectedMode.UI;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Infrastructure.VS;
+using SonarLint.VisualStudio.Integration.MefServices;
 using SonarLint.VisualStudio.Integration.TeamExplorer;
 using SonarLint.VisualStudio.IssueVisualization.Helpers;
 using SonarLint.VisualStudio.Roslyn.Suppressions.InProcess;
@@ -69,6 +70,7 @@ public class SonarLintIntegrationPackage : AsyncPackage
 
         private ILogger logger;
         private IRoslynSettingsFileSynchronizer roslynSettingsFileSynchronizer;
+        private ISharedBindingSuggestionService suggestSharedBindingGoldBar;
 
         protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress<ServiceProgressData> progress)
         {
@@ -97,13 +99,15 @@ private async System.Threading.Tasks.Task InitOnUIThreadAsync()
                     serviceProvider.GetMefService<IBrowserService>(),
                     ShowOptionPage,
                     serviceProvider.GetMefService<IConnectedModeServices>(),
-                    serviceProvider.GetMefService<ISolutionInfoProvider>(),
-                    serviceProvider.GetMefService<IBindingController>());
+                    serviceProvider.GetMefService<IConnectedModeBindingServices>());
 
                 this.roslynSettingsFileSynchronizer = await this.GetMefServiceAsync<IRoslynSettingsFileSynchronizer>();
                 roslynSettingsFileSynchronizer.UpdateFileStorageAsync().Forget(); // don't wait for it to finish
                 Debug.Assert(threadHandling.CheckAccess(), "Still expecting to be on the UI thread");
 
+                suggestSharedBindingGoldBar = serviceProvider.GetMefService<ISharedBindingSuggestionService>();
+                suggestSharedBindingGoldBar.Suggest();
+
                 logger.WriteLine(Resources.Strings.SL_InitializationComplete);
             }
             catch (Exception ex) when (!ErrorHandler.IsCriticalException(ex))
@@ -119,6 +123,7 @@ protected override void Dispose(bool disposing)
             if (disposing)
             {
                 this.roslynSettingsFileSynchronizer?.Dispose();
+                suggestSharedBindingGoldBar?.Dispose();
                 this.roslynSettingsFileSynchronizer = null;
             }
         }
diff --git a/src/Integration/Connection/ConnectionController.cs b/src/Integration/Connection/ConnectionController.cs
index 04f2f1937..07d389d5c 100644
--- a/src/Integration/Connection/ConnectionController.cs
+++ b/src/Integration/Connection/ConnectionController.cs
@@ -23,6 +23,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using SonarLint.VisualStudio.ConnectedMode.Binding;
+using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Integration.Binding;
 using SonarLint.VisualStudio.Integration.Progress;
@@ -45,11 +46,13 @@ internal sealed class ConnectionController : HostedCommandControllerBase, IConne
     {
         private readonly IAutoBindTrigger autoBindTrigger;
         private readonly IHost host;
+        private readonly ISharedBindingConfigProvider sharedBindingConfigProvider;
+        private readonly ICredentialStoreService credentialStoreService;
         private readonly IConnectionInformationProvider connectionProvider;
         private readonly ISolutionInfoProvider solutionInfoProvider;
 
-        public ConnectionController(IServiceProvider serviceProvider, IHost host, IAutoBindTrigger autoBindTrigger)
-            : this(serviceProvider, host, autoBindTrigger, null, null)
+        public ConnectionController(IServiceProvider serviceProvider, IHost host, IAutoBindTrigger autoBindTrigger, ISharedBindingConfigProvider sharedBindingConfigProvider, ICredentialStoreService credentialStoreService)
+            : this(serviceProvider, host, autoBindTrigger, null, null, sharedBindingConfigProvider, credentialStoreService)
         {
             if (autoBindTrigger == null)
             {
@@ -61,10 +64,14 @@ public ConnectionController(IServiceProvider serviceProvider, IHost host, IAutoB
             IHost host,
             IAutoBindTrigger autoBindTrigger,
             IConnectionInformationProvider connectionProvider,
-            IConnectionWorkflowExecutor workflowExecutor)
+            IConnectionWorkflowExecutor workflowExecutor, 
+            ISharedBindingConfigProvider sharedBindingConfigProvider, 
+            ICredentialStoreService credentialStoreService)
             : base(serviceProvider)
         {
             this.host = host ?? throw new ArgumentNullException(nameof(host));
+            this.sharedBindingConfigProvider = sharedBindingConfigProvider;
+            this.credentialStoreService = credentialStoreService;
             this.autoBindTrigger = workflowExecutor == null ? autoBindTrigger : null;
             this.WorkflowExecutor = workflowExecutor ?? this;
             this.connectionProvider = connectionProvider ?? this;
@@ -116,8 +123,8 @@ private void OnConnect(ConnectConfiguration configuration)
 
             ConnectionInformation connectionInfo;
 
-            var sharedConfig = host.SharedBindingConfig;
-            var credentials = host.GetCredentialsForSharedConfig();
+            var sharedConfig = sharedBindingConfigProvider.GetSharedBinding();
+            var credentials = sharedConfig == null ? null : credentialStoreService.ReadCredentials(sharedConfig.Uri);
             var useSharedConfig = configuration?.UseSharedBinding ?? false;
 
             if (useSharedConfig && sharedConfig != null)
diff --git a/src/Integration/MefServices/IHost.cs b/src/Integration/MefServices/IHost.cs
index af777229a..3e9c5a3fe 100644
--- a/src/Integration/MefServices/IHost.cs
+++ b/src/Integration/MefServices/IHost.cs
@@ -40,10 +40,6 @@ internal interface IHost
         /// </summary>
         IStateManager VisualStateManager { get; }
 
-        SharedBindingConfigModel SharedBindingConfig { get; }
-
-        Credential GetCredentialsForSharedConfig();
-
         /// <summary>
         /// The currently active section. Null when no active section.
         /// </summary>
diff --git a/src/Integration/MefServices/SharedBindingSuggestionService.cs b/src/Integration/MefServices/SharedBindingSuggestionService.cs
index cbf7fe475..89cbf795e 100644
--- a/src/Integration/MefServices/SharedBindingSuggestionService.cs
+++ b/src/Integration/MefServices/SharedBindingSuggestionService.cs
@@ -18,86 +18,73 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-using System;
 using System.ComponentModel.Composition;
+using System.Windows;
 using SonarLint.VisualStudio.ConnectedMode.Binding.Suggestion;
 using SonarLint.VisualStudio.ConnectedMode.Shared;
-using SonarLint.VisualStudio.Integration.Connection;
-using SonarLint.VisualStudio.Integration.TeamExplorer;
-using SonarLint.VisualStudio.Integration.WPF;
-using SonarQube.Client;
+using SonarLint.VisualStudio.ConnectedMode.UI;
+using SonarLint.VisualStudio.ConnectedMode.UI.ManageBinding;
+using SonarLint.VisualStudio.Core;
+using SonarLint.VisualStudio.Core.Binding;
 
 namespace SonarLint.VisualStudio.Integration.MefServices
 {
-    internal interface ISharedBindingSuggestionService
+    public interface ISharedBindingSuggestionService : IDisposable
     {
-        void Suggest(ServerType? serverType, Func<ICommand<ConnectConfiguration>> connectCommandProvider);
-
-        void Close();
+        void Suggest();
     }
     
     [Export(typeof(ISharedBindingSuggestionService))]
     [PartCreationPolicy(CreationPolicy.Shared)]
-    internal class SharedBindingSuggestionService : ISharedBindingSuggestionService
+    internal sealed class SharedBindingSuggestionService : ISharedBindingSuggestionService
     {
-        internal /* for testing */ readonly ConnectConfiguration autobindEnabledConfiguration =
-            new ConnectConfiguration { UseSharedBinding = true };
-
         private readonly ISuggestSharedBindingGoldBar suggestSharedBindingGoldBar;
-        private readonly ITeamExplorerController teamExplorerController;
-        private readonly IConnectedModeWindowEventBasedScheduler connectedModeWindowEventBasedScheduler;
+        private readonly IConnectedModeServices connectedModeServices;
+        private readonly IConnectedModeBindingServices connectedModeBindingServices;
+        private readonly IActiveSolutionTracker activeSolutionTracker;
 
         [ImportingConstructor]
-        public SharedBindingSuggestionService(ISuggestSharedBindingGoldBar suggestSharedBindingGoldBar,
-            ITeamExplorerController teamExplorerController,
-            IConnectedModeWindowEventBasedScheduler connectedModeWindowEventBasedScheduler)
+        public SharedBindingSuggestionService(
+            ISuggestSharedBindingGoldBar suggestSharedBindingGoldBar,
+            IConnectedModeServices connectedModeServices,
+            IConnectedModeBindingServices connectedModeBindingServices,
+            IActiveSolutionTracker activeSolutionTracker)
         {
             this.suggestSharedBindingGoldBar = suggestSharedBindingGoldBar;
-            this.teamExplorerController = teamExplorerController;
-            this.connectedModeWindowEventBasedScheduler = connectedModeWindowEventBasedScheduler;
+            this.connectedModeServices = connectedModeServices;
+            this.connectedModeBindingServices = connectedModeBindingServices;
+            this.activeSolutionTracker = activeSolutionTracker;
+
+            this.activeSolutionTracker.ActiveSolutionChanged += OnActiveSolutionChanged;
         }
-        
-        public void Suggest(ServerType? serverType, Func<ICommand<ConnectConfiguration>> connectCommandProvider)
+
+        public void Suggest()
         {
-            if (serverType == null)
+            var sharedBindingConfig = connectedModeBindingServices.SharedBindingConfigProvider.GetSharedBinding();
+            var isStandalone = connectedModeServices.ConfigurationProvider.GetConfiguration().Mode == SonarLintMode.Standalone;
+
+            if (sharedBindingConfig?.GetServerType() is { } serverType && isStandalone)
             {
-                return;
+                suggestSharedBindingGoldBar.Show(serverType, ShowManageBindingDialog);
             }
-            
-            suggestSharedBindingGoldBar.Show(serverType.Value, () => ConnectAfterTeamExplorerInitialized(connectCommandProvider));
         }
 
-        public void Close()
+        public void Dispose()
         {
-            suggestSharedBindingGoldBar.Close();
+            activeSolutionTracker.ActiveSolutionChanged -= OnActiveSolutionChanged;
         }
 
-        private void ConnectAfterTeamExplorerInitialized(Func<ICommand<ConnectConfiguration>> connectCommandProvider)
+        private void ShowManageBindingDialog()
         {
-            if (IsConnectedModeWindowLoaded(connectCommandProvider, out var connectCommand))
-            {
-                teamExplorerController.ShowSonarQubePage();
-                Autobind(connectCommand);
-            }
-            else
-            {
-                connectedModeWindowEventBasedScheduler.ScheduleActionOnNextEvent(() => Autobind(connectCommandProvider()));
-                teamExplorerController.ShowSonarQubePage();
-            }
+            var manageBindingDialog = new ManageBindingDialog(connectedModeServices, connectedModeBindingServices, useSharedBindingOnInitialization:true);
+            manageBindingDialog.ShowDialog(Application.Current.MainWindow);
         }
 
-        private bool IsConnectedModeWindowLoaded(Func<ICommand<ConnectConfiguration>> connectCommandProvider,
-            out ICommand<ConnectConfiguration> connectCommand)
-        {
-            connectCommand = connectCommandProvider();
-            return connectCommand != null;
-        }
-        
-        private void Autobind(ICommand<ConnectConfiguration> connectCommand)
+        private void OnActiveSolutionChanged(object sender, ActiveSolutionChangedEventArgs e)
         {
-            if (connectCommand?.CanExecute(autobindEnabledConfiguration) ?? false)
+            if (e.IsSolutionOpen)
             {
-                connectCommand.Execute(autobindEnabledConfiguration);
+                Suggest();
             }
         }
     }
diff --git a/src/Integration/MefServices/VsSessionHost.cs b/src/Integration/MefServices/VsSessionHost.cs
index 05b6dabe6..d561053e7 100644
--- a/src/Integration/MefServices/VsSessionHost.cs
+++ b/src/Integration/MefServices/VsSessionHost.cs
@@ -18,16 +18,9 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-using System;
 using System.ComponentModel.Composition;
-using System.Diagnostics;
-using Microsoft.Alm.Authentication;
-using SonarLint.VisualStudio.ConnectedMode.Binding;
-using SonarLint.VisualStudio.ConnectedMode.Binding.Suggestion;
-using SonarLint.VisualStudio.ConnectedMode.Shared;
 using SonarLint.VisualStudio.Core;
 using SonarLint.VisualStudio.Core.Binding;
-using SonarLint.VisualStudio.Integration.Connection;
 using SonarLint.VisualStudio.Integration.MefServices;
 using SonarLint.VisualStudio.Integration.Progress;
 using SonarLint.VisualStudio.Integration.State;
@@ -43,14 +36,9 @@ internal sealed class VsSessionHost : IHost, IProgressStepRunnerWrapper, IDispos
     {
         private readonly IActiveSolutionTracker solutionTracker;
         private readonly IConfigurationProvider configurationProvider;
-        private readonly ISharedBindingConfigProvider sharedBindingConfigProvider;
-        private readonly ICredentialStoreService credentialStoreService;
         private readonly IConnectedModeWindowEventListener connectedModeWindowEventListener;
-        private readonly ISharedBindingSuggestionService sharedBindingSuggestionService;
-
         private readonly IProgressStepRunnerWrapper progressStepRunner;
 
-
         private bool isDisposed;
         private bool resetBindingWhenAttaching = true;
 
@@ -58,10 +46,7 @@ internal sealed class VsSessionHost : IHost, IProgressStepRunnerWrapper, IDispos
         public VsSessionHost(ISonarQubeService sonarQubeService,
             IActiveSolutionTracker solutionTracker,
             IConfigurationProvider configurationProvider,
-            ISharedBindingConfigProvider sharedBindingConfigProvider,
-            ICredentialStoreService credentialStoreService,
             IConnectedModeWindowEventListener connectedModeWindowEventListener,
-            ISharedBindingSuggestionService sharedBindingSuggestionService,
             ILogger logger)
             : this(
                 null,
@@ -69,10 +54,7 @@ public VsSessionHost(ISonarQubeService sonarQubeService,
                 sonarQubeService,
                 solutionTracker,
                 configurationProvider,
-                sharedBindingConfigProvider,
-                credentialStoreService,
                 connectedModeWindowEventListener,
-                sharedBindingSuggestionService,
                 logger)
         {
         }
@@ -82,10 +64,7 @@ public VsSessionHost(ISonarQubeService sonarQubeService,
             ISonarQubeService sonarQubeService,
             IActiveSolutionTracker solutionTracker,
             IConfigurationProvider configurationProvider,
-            ISharedBindingConfigProvider sharedBindingConfigProvider,
-            ICredentialStoreService credentialStoreService,
             IConnectedModeWindowEventListener connectedModeWindowEventListener,
-            ISharedBindingSuggestionService sharedBindingSuggestionService,
             ILogger logger)
         {
             this.VisualStateManager = state ?? new StateManager(this, new TransferableVisualState());
@@ -93,10 +72,7 @@ public VsSessionHost(ISonarQubeService sonarQubeService,
             this.SonarQubeService = sonarQubeService ?? throw new ArgumentNullException(nameof(sonarQubeService));
             this.solutionTracker = solutionTracker ?? throw new ArgumentNullException(nameof(solutionTracker));
             this.configurationProvider = configurationProvider ?? throw new ArgumentNullException(nameof(configurationProvider));
-            this.sharedBindingConfigProvider = sharedBindingConfigProvider;
-            this.credentialStoreService = credentialStoreService;
             this.connectedModeWindowEventListener = connectedModeWindowEventListener;
-            this.sharedBindingSuggestionService = sharedBindingSuggestionService;
             this.solutionTracker.ActiveSolutionChanged += this.OnActiveSolutionChanged;
             this.Logger = logger ?? throw new ArgumentNullException(nameof(logger));
             connectedModeWindowEventListener.SubscribeToConnectedModeWindowEvents(this);
@@ -118,17 +94,9 @@ void IProgressStepRunnerWrapper.ChangeHost(IProgressControlHost host)
         public event EventHandler ActiveSectionChanged;
 
         public IStateManager VisualStateManager { get; }
-        public SharedBindingConfigModel SharedBindingConfig { get; private set; }
 
         public ISonarQubeService SonarQubeService { get; }
 
-        public Credential GetCredentialsForSharedConfig()
-        {
-            return SharedBindingConfig == null 
-                ? null 
-                : credentialStoreService.ReadCredentials(SharedBindingConfig.Uri);
-        }
-
         public ISectionController ActiveSection { get; private set; }
 
         public ILogger Logger { get; }
@@ -222,15 +190,6 @@ private void ResetBinding(bool abortCurrentlyRunningWorklows, bool clearCurrentB
             if (clearCurrentBinding || bindingConfig == null || bindingConfig.Mode == SonarLintMode.Standalone)
             {
                 this.ClearCurrentBinding();
-
-                if (!clearCurrentBinding) // when solution is open, but unbound
-                {
-                    UpdateSharedBindingSuggestion();
-                }
-                else
-                {
-                    sharedBindingSuggestionService.Close();
-                }
             }
             else
             {
@@ -248,16 +207,6 @@ private void ResetBinding(bool abortCurrentlyRunningWorklows, bool clearCurrentB
             }
         }
 
-        private void UpdateSharedBindingSuggestion()
-        {
-            SharedBindingConfig = sharedBindingConfigProvider.GetSharedBinding();
-
-            VisualStateManager.HasSharedBinding = SharedBindingConfig != null;
-            VisualStateManager.ResetConnectionConfiguration();
-
-            sharedBindingSuggestionService.Suggest(SharedBindingConfig.GetServerType(),() => this.ActiveSection?.ConnectCommand);
-        }
-
         private void ClearCurrentBinding()
         {
             this.VisualStateManager.BoundProjectKey = null;
@@ -268,8 +217,6 @@ private void ClearCurrentBinding()
 
         private void ApplyBindingInformation(BindingConfiguration bindingConfig)
         {
-            SharedBindingConfig = null;
-
             // Set the project key that should become bound once the connection workflow has completed
             this.VisualStateManager.BoundProjectKey = bindingConfig.Project.ServerProjectKey;
             this.VisualStateManager.BoundProjectName = bindingConfig.Project.ServerProjectKey;
@@ -316,7 +263,6 @@ private void Dispose(bool disposing)
                 {
                     this.solutionTracker.ActiveSolutionChanged -= this.OnActiveSolutionChanged;
                     connectedModeWindowEventListener.Dispose();
-                    sharedBindingSuggestionService.Close();
                 }
 
                 this.isDisposed = true;
diff --git a/src/TestInfrastructure/Framework/ConfigurableHost.cs b/src/TestInfrastructure/Framework/ConfigurableHost.cs
index f3edf98b3..d52d512fd 100644
--- a/src/TestInfrastructure/Framework/ConfigurableHost.cs
+++ b/src/TestInfrastructure/Framework/ConfigurableHost.cs
@@ -42,13 +42,6 @@ public ConfigurableHost()
 
         public event EventHandler ActiveSectionChanged;
 
-        public SharedBindingConfigModel SharedBindingConfig { get; set; }
-
-        public Credential GetCredentialsForSharedConfig()
-        {
-            return CredentialsForSharedConfig;
-        }
-
         public ISectionController ActiveSection
         {
             get;
@@ -90,8 +83,6 @@ public void SetActiveSection(ISectionController section)
         #endregion IHost
 
         #region Test helpers
-
-        public Credential CredentialsForSharedConfig { get; set; }
         
         public void SimulateActiveSectionChanged()
         {