diff --git a/App/App.csproj b/App/App.csproj
index fcfb92f..68cef65 100644
--- a/App/App.csproj
+++ b/App/App.csproj
@@ -57,6 +57,7 @@
     <ItemGroup>
         <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.0" />
         <PackageReference Include="CommunityToolkit.WinUI.Controls.Primitives" Version="8.2.250402" />
+        <PackageReference Include="CommunityToolkit.WinUI.Controls.SettingsControls" Version="8.2.250402" />
         <PackageReference Include="CommunityToolkit.WinUI.Extensions" Version="8.2.250402" />
         <PackageReference Include="DependencyPropertyGenerator" Version="1.5.0">
             <PrivateAssets>all</PrivateAssets>
diff --git a/App/App.xaml.cs b/App/App.xaml.cs
index 06ab676..87afcb3 100644
--- a/App/App.xaml.cs
+++ b/App/App.xaml.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -44,6 +43,10 @@ public partial class App : Application
     private readonly ILogger<App> _logger;
     private readonly IUriHandler _uriHandler;
 
+    private readonly ISettingsManager<CoderConnectSettings> _settingsManager;
+
+    private readonly IHostApplicationLifetime _appLifetime;
+
     public App()
     {
         var builder = Host.CreateApplicationBuilder();
@@ -90,6 +93,13 @@ public App()
         // FileSyncListMainPage is created by FileSyncListWindow.
         services.AddTransient<FileSyncListWindow>();
 
+        services.AddSingleton<ISettingsManager<CoderConnectSettings>, SettingsManager<CoderConnectSettings>>();
+        services.AddSingleton<IStartupManager, StartupManager>();
+        // SettingsWindow views and view models
+        services.AddTransient<SettingsViewModel>();
+        // SettingsMainPage is created by SettingsWindow.
+        services.AddTransient<SettingsWindow>();
+
         // DirectoryPickerWindow views and view models are created by FileSyncListViewModel.
 
         // TrayWindow views and view models
@@ -107,8 +117,10 @@ public App()
         services.AddTransient<TrayWindow>();
 
         _services = services.BuildServiceProvider();
-        _logger = (ILogger<App>)_services.GetService(typeof(ILogger<App>))!;
-        _uriHandler = (IUriHandler)_services.GetService(typeof(IUriHandler))!;
+        _logger = _services.GetRequiredService<ILogger<App>>();
+        _uriHandler = _services.GetRequiredService<IUriHandler>();
+        _settingsManager = _services.GetRequiredService<ISettingsManager<CoderConnectSettings>>();
+        _appLifetime = _services.GetRequiredService<IHostApplicationLifetime>();
 
         InitializeComponent();
     }
@@ -129,58 +141,8 @@ public async Task ExitApplication()
     protected override void OnLaunched(LaunchActivatedEventArgs args)
     {
         _logger.LogInformation("new instance launched");
-        // Start connecting to the manager in the background.
-        var rpcController = _services.GetRequiredService<IRpcController>();
-        if (rpcController.GetState().RpcLifecycle == RpcLifecycle.Disconnected)
-            // Passing in a CT with no cancellation is desired here, because
-            // the named pipe open will block until the pipe comes up.
-            _logger.LogDebug("reconnecting with VPN service");
-        _ = rpcController.Reconnect(CancellationToken.None).ContinueWith(t =>
-        {
-            if (t.Exception != null)
-            {
-                _logger.LogError(t.Exception, "failed to connect to VPN service");
-#if DEBUG
-                Debug.WriteLine(t.Exception);
-                Debugger.Break();
-#endif
-            }
-        });
-
-        // Load the credentials in the background.
-        var credentialManagerCts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
-        var credentialManager = _services.GetRequiredService<ICredentialManager>();
-        _ = credentialManager.LoadCredentials(credentialManagerCts.Token).ContinueWith(t =>
-        {
-            if (t.Exception != null)
-            {
-                _logger.LogError(t.Exception, "failed to load credentials");
-#if DEBUG
-                Debug.WriteLine(t.Exception);
-                Debugger.Break();
-#endif
-            }
 
-            credentialManagerCts.Dispose();
-        }, CancellationToken.None);
-
-        // Initialize file sync.
-        // We're adding a 5s delay here to avoid race conditions when loading the mutagen binary.
-
-        _ = Task.Delay(5000).ContinueWith((_) =>
-        {
-            var syncSessionCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-            var syncSessionController = _services.GetRequiredService<ISyncSessionController>();
-            syncSessionController.RefreshState(syncSessionCts.Token).ContinueWith(
-                t =>
-                {
-                    if (t.IsCanceled || t.Exception != null)
-                    {
-                        _logger.LogError(t.Exception, "failed to refresh sync state (canceled = {canceled})", t.IsCanceled);
-                    }
-                    syncSessionCts.Dispose();
-                }, CancellationToken.None);
-        });
+        _ = InitializeServicesAsync(_appLifetime.ApplicationStopping);
 
         // Prevent the TrayWindow from closing, just hide it.
         var trayWindow = _services.GetRequiredService<TrayWindow>();
@@ -192,6 +154,74 @@ protected override void OnLaunched(LaunchActivatedEventArgs args)
         };
     }
 
+    /// <summary>
+    /// Loads stored VPN credentials, reconnects the RPC controller,
+    /// and (optionally) starts the VPN tunnel on application launch.
+    /// </summary>
+    private async Task InitializeServicesAsync(CancellationToken cancellationToken = default)
+    {
+        var credentialManager = _services.GetRequiredService<ICredentialManager>();
+        var rpcController = _services.GetRequiredService<IRpcController>();
+
+        using var credsCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        credsCts.CancelAfter(TimeSpan.FromSeconds(15));
+
+        var loadCredsTask = credentialManager.LoadCredentials(credsCts.Token);
+        var reconnectTask = rpcController.Reconnect(cancellationToken);
+        var settingsTask = _settingsManager.Read(cancellationToken);
+
+        var dependenciesLoaded = true;
+
+        try
+        {
+            await Task.WhenAll(loadCredsTask, reconnectTask, settingsTask);
+        }
+        catch (Exception)
+        {
+            if (loadCredsTask.IsFaulted)
+                _logger.LogError(loadCredsTask.Exception!.GetBaseException(),
+                                 "Failed to load credentials");
+
+            if (reconnectTask.IsFaulted)
+                _logger.LogError(reconnectTask.Exception!.GetBaseException(),
+                                 "Failed to connect to VPN service");
+
+            if (settingsTask.IsFaulted)
+                _logger.LogError(settingsTask.Exception!.GetBaseException(),
+                                 "Failed to fetch Coder Connect settings");
+
+            // Don't attempt to connect if we failed to load credentials or reconnect.
+            // This will prevent the app from trying to connect to the VPN service.
+            dependenciesLoaded = false;
+        }
+
+        var attemptCoderConnection = settingsTask.Result?.ConnectOnLaunch ?? false;
+        if (dependenciesLoaded && attemptCoderConnection)
+        {
+            try
+            {
+                await rpcController.StartVpn(cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Failed to connect on launch");
+            }
+        }
+
+        // Initialize file sync.
+        using var syncSessionCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        syncSessionCts.CancelAfter(TimeSpan.FromSeconds(10));
+        var syncSessionController = _services.GetRequiredService<ISyncSessionController>();
+        try
+        {
+            await syncSessionController.RefreshState(syncSessionCts.Token);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Failed to refresh sync session state {ex.Message}", ex);
+        }
+    }
+
     public void OnActivated(object? sender, AppActivationArguments args)
     {
         switch (args.Kind)
diff --git a/App/Models/Settings.cs b/App/Models/Settings.cs
new file mode 100644
index 0000000..ec4c61b
--- /dev/null
+++ b/App/Models/Settings.cs
@@ -0,0 +1,62 @@
+namespace Coder.Desktop.App.Models;
+
+public interface ISettings<T> : ICloneable<T>
+{
+    /// <summary>
+    /// FileName where the settings are stored.
+    /// </summary>
+    static abstract string SettingsFileName { get; }
+
+    /// <summary>
+    /// Gets the version of the settings schema.
+    /// </summary>
+    int Version { get; }
+}
+
+public interface ICloneable<T>
+{
+    /// <summary>
+    /// Creates a deep copy of the settings object.
+    /// </summary>
+    /// <returns>A new instance of the settings object with the same values.</returns>
+    T Clone();
+}
+
+/// <summary>
+/// CoderConnect settings class that holds the settings for the CoderConnect feature.
+/// </summary>
+public class CoderConnectSettings : ISettings<CoderConnectSettings>
+{
+    public static string SettingsFileName { get; } = "coder-connect-settings.json";
+    public int Version { get; set; }
+    /// <summary>
+    /// When this is true, CoderConnect will automatically connect to the Coder VPN when the application starts.
+    /// </summary>
+    public bool ConnectOnLaunch { get; set; }
+
+    /// <summary>
+    /// CoderConnect current settings version. Increment this when the settings schema changes.
+    /// In future iterations we will be able to handle migrations when the user has
+    /// an older version.
+    /// </summary>
+    private const int VERSION = 1;
+
+    public CoderConnectSettings()
+    {
+        Version = VERSION;
+
+        ConnectOnLaunch = false;
+    }
+
+    public CoderConnectSettings(int? version, bool connectOnLaunch)
+    {
+        Version = version ?? VERSION;
+
+        ConnectOnLaunch = connectOnLaunch;
+    }
+
+    public CoderConnectSettings Clone()
+    {
+        return new CoderConnectSettings(Version, ConnectOnLaunch);
+    }
+}
diff --git a/App/Services/SettingsManager.cs b/App/Services/SettingsManager.cs
new file mode 100644
index 0000000..886d5d2
--- /dev/null
+++ b/App/Services/SettingsManager.cs
@@ -0,0 +1,144 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Coder.Desktop.App.Models;
+
+namespace Coder.Desktop.App.Services;
+
+/// <summary>
+/// Settings contract exposing properties for app settings.
+/// </summary>
+public interface ISettingsManager<T> where T : ISettings<T>, new()
+{
+    /// <summary>
+    /// Reads the settings from the file system or returns from cache if available.
+    /// Returned object is always a cloned instance, so it can be modified without affecting the stored settings.
+    /// </summary>
+    /// <param name="ct"></param>
+    /// <returns></returns>
+    Task<T> Read(CancellationToken ct = default);
+    /// <summary>
+    /// Writes the settings to the file system.
+    /// </summary>
+    /// <param name="settings">Object containing the settings.</param>
+    /// <param name="ct"></param>
+    /// <returns></returns>
+    Task Write(T settings, CancellationToken ct = default);
+}
+
+/// <summary>
+/// Implemention of <see cref="ISettingsManager"/> that persists settings to a JSON file
+/// located in the user's local application data folder.
+/// </summary>
+public sealed class SettingsManager<T> : ISettingsManager<T> where T : ISettings<T>, new()
+{
+    private readonly string _settingsFilePath;
+    private readonly string _appName = "CoderDesktop";
+    private string _fileName;
+
+    private T? _cachedSettings;
+
+    private readonly SemaphoreSlim _gate = new(1, 1);
+    private static readonly TimeSpan LockTimeout = TimeSpan.FromSeconds(3);
+
+    /// <param name="settingsFilePath">
+    /// For unit‑tests you can pass an absolute path that already exists.
+    /// Otherwise the settings file will be created in the user's local application data folder.
+    /// </param>
+    public SettingsManager(string? settingsFilePath = null)
+    {
+        if (settingsFilePath is null)
+        {
+            settingsFilePath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        }
+        else if (!Path.IsPathRooted(settingsFilePath))
+        {
+            throw new ArgumentException("settingsFilePath must be an absolute path if provided", nameof(settingsFilePath));
+        }
+
+        var folder = Path.Combine(
+                settingsFilePath,
+                _appName);
+
+        Directory.CreateDirectory(folder);
+
+        _fileName = T.SettingsFileName;
+        _settingsFilePath = Path.Combine(folder, _fileName);
+    }
+
+    public async Task<T> Read(CancellationToken ct = default)
+    {
+        if (_cachedSettings is not null)
+        {
+            // return cached settings if available
+            return _cachedSettings.Clone();
+        }
+
+        // try to get the lock with short timeout
+        if (!await _gate.WaitAsync(LockTimeout, ct).ConfigureAwait(false))
+            throw new InvalidOperationException(
+                $"Could not acquire the settings lock within {LockTimeout.TotalSeconds} s.");
+
+        try
+        {
+            if (!File.Exists(_settingsFilePath))
+                return new();
+
+            var json = await File.ReadAllTextAsync(_settingsFilePath, ct)
+                                 .ConfigureAwait(false);
+
+            // deserialize; fall back to default(T) if empty or malformed
+            var result = JsonSerializer.Deserialize<T>(json)!;
+            _cachedSettings = result;
+            return _cachedSettings.Clone(); // return a fresh instance of the settings
+        }
+        catch (OperationCanceledException)
+        {
+            throw; // propagate caller-requested cancellation
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException(
+                $"Failed to read settings from {_settingsFilePath}. " +
+                "The file may be corrupted, malformed or locked.", ex);
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task Write(T settings, CancellationToken ct = default)
+    {
+        // try to get the lock with short timeout
+        if (!await _gate.WaitAsync(LockTimeout, ct).ConfigureAwait(false))
+            throw new InvalidOperationException(
+                $"Could not acquire the settings lock within {LockTimeout.TotalSeconds} s.");
+
+        try
+        {
+            // overwrite the settings file with the new settings
+            var json = JsonSerializer.Serialize(
+                settings, new JsonSerializerOptions() { WriteIndented = true });
+            _cachedSettings = settings; // cache the settings
+            await File.WriteAllTextAsync(_settingsFilePath, json, ct)
+                      .ConfigureAwait(false);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;  // let callers observe cancellation
+        }
+        catch (Exception ex)
+        {
+            throw new InvalidOperationException(
+                $"Failed to persist settings to {_settingsFilePath}. " +
+                "The file may be corrupted, malformed or locked.", ex);
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+}
diff --git a/App/Services/StartupManager.cs b/App/Services/StartupManager.cs
new file mode 100644
index 0000000..2ab7631
--- /dev/null
+++ b/App/Services/StartupManager.cs
@@ -0,0 +1,84 @@
+using Microsoft.Win32;
+using System;
+using System.Diagnostics;
+using System.Security;
+
+namespace Coder.Desktop.App.Services;
+
+public interface IStartupManager
+{
+    /// <summary>
+    /// Adds the current executable to the per‑user Run key. Returns <c>true</c> if successful.
+    /// Fails (returns <c>false</c>) when blocked by policy or lack of permissions.
+    /// </summary>
+    bool Enable();
+    /// <summary>
+    /// Removes the value from the Run key (no-op if missing).
+    /// </summary>
+    void Disable();
+    /// <summary>
+    /// Checks whether the value exists in the Run key.
+    /// </summary>
+    bool IsEnabled();
+    /// <summary>
+    /// Detects whether group policy disables per‑user startup programs.
+    /// Mirrors <see cref="Windows.ApplicationModel.StartupTaskState.DisabledByPolicy"/>.
+    /// </summary>
+    bool IsDisabledByPolicy();
+}
+
+public class StartupManager : IStartupManager
+{
+    private const string RunKey = @"Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+    private const string PoliciesExplorerUser = @"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer";
+    private const string PoliciesExplorerMachine = @"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer";
+    private const string DisableCurrentUserRun = "DisableCurrentUserRun";
+    private const string DisableLocalMachineRun = "DisableLocalMachineRun";
+
+    private const string _defaultValueName = "CoderDesktopApp";
+
+    public bool Enable()
+    {
+        if (IsDisabledByPolicy())
+            return false;
+
+        string exe = Process.GetCurrentProcess().MainModule!.FileName;
+        try
+        {
+            using var key = Registry.CurrentUser.OpenSubKey(RunKey, writable: true)
+                            ?? Registry.CurrentUser.CreateSubKey(RunKey)!;
+            key.SetValue(_defaultValueName, $"\"{exe}\"");
+            return true;
+        }
+        catch (UnauthorizedAccessException) { return false; }
+        catch (SecurityException) { return false; }
+    }
+
+    public void Disable()
+    {
+        using var key = Registry.CurrentUser.OpenSubKey(RunKey, writable: true);
+        key?.DeleteValue(_defaultValueName, throwOnMissingValue: false);
+    }
+
+    public bool IsEnabled()
+    {
+        using var key = Registry.CurrentUser.OpenSubKey(RunKey);
+        return key?.GetValue(_defaultValueName) != null;
+    }
+
+    public bool IsDisabledByPolicy()
+    {
+        // User policy – HKCU
+        using (var keyUser = Registry.CurrentUser.OpenSubKey(PoliciesExplorerUser))
+        {
+            if ((int?)keyUser?.GetValue(DisableCurrentUserRun) == 1) return true;
+        }
+        // Machine policy – HKLM
+        using (var keyMachine = Registry.LocalMachine.OpenSubKey(PoliciesExplorerMachine))
+        {
+            if ((int?)keyMachine?.GetValue(DisableLocalMachineRun) == 1) return true;
+        }
+        return false;
+    }
+}
+
diff --git a/App/ViewModels/SettingsViewModel.cs b/App/ViewModels/SettingsViewModel.cs
new file mode 100644
index 0000000..721ea95
--- /dev/null
+++ b/App/ViewModels/SettingsViewModel.cs
@@ -0,0 +1,81 @@
+using Coder.Desktop.App.Models;
+using Coder.Desktop.App.Services;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Microsoft.Extensions.Logging;
+using System;
+
+namespace Coder.Desktop.App.ViewModels;
+
+public partial class SettingsViewModel : ObservableObject
+{
+    private readonly ILogger<SettingsViewModel> _logger;
+
+    [ObservableProperty]
+    public partial bool ConnectOnLaunch { get; set; }
+
+    [ObservableProperty]
+    public partial bool StartOnLoginDisabled { get; set; }
+
+    [ObservableProperty]
+    public partial bool StartOnLogin { get; set; }
+
+    private ISettingsManager<CoderConnectSettings> _connectSettingsManager;
+    private CoderConnectSettings _connectSettings = new CoderConnectSettings();
+    private IStartupManager _startupManager;
+
+    public SettingsViewModel(ILogger<SettingsViewModel> logger, ISettingsManager<CoderConnectSettings> settingsManager, IStartupManager startupManager)
+    {
+        _connectSettingsManager = settingsManager;
+        _startupManager = startupManager;
+        _logger = logger;
+        _connectSettings = settingsManager.Read().GetAwaiter().GetResult();
+        StartOnLogin = startupManager.IsEnabled();
+        ConnectOnLaunch = _connectSettings.ConnectOnLaunch;
+
+        // Various policies can disable the "Start on login" option.
+        // We disable the option in the UI if the policy is set.
+        StartOnLoginDisabled = _startupManager.IsDisabledByPolicy();
+
+        // Ensure the StartOnLogin property matches the current startup state.
+        if (StartOnLogin != _startupManager.IsEnabled())
+        {
+            StartOnLogin = _startupManager.IsEnabled();
+        }
+    }
+
+    partial void OnConnectOnLaunchChanged(bool oldValue, bool newValue)
+    {
+        if (oldValue == newValue)
+            return;
+        try
+        {
+            _connectSettings.ConnectOnLaunch = ConnectOnLaunch;
+            _connectSettingsManager.Write(_connectSettings);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error saving Coder Connect settings: {ex.Message}");
+        }
+    }
+
+    partial void OnStartOnLoginChanged(bool oldValue, bool newValue)
+    {
+        if (oldValue == newValue)
+            return;
+        try
+        {
+            if (StartOnLogin)
+            {
+                _startupManager.Enable();
+            }
+            else
+            {
+                _startupManager.Disable();
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError($"Error setting StartOnLogin in registry: {ex.Message}");
+        }
+    }
+}
diff --git a/App/ViewModels/TrayWindowViewModel.cs b/App/ViewModels/TrayWindowViewModel.cs
index d8b3182..c49fef7 100644
--- a/App/ViewModels/TrayWindowViewModel.cs
+++ b/App/ViewModels/TrayWindowViewModel.cs
@@ -39,6 +39,8 @@ public partial class TrayWindowViewModel : ObservableObject, IAgentExpanderHost
 
     private FileSyncListWindow? _fileSyncListWindow;
 
+    private SettingsWindow? _settingsWindow;
+
     private DispatcherQueue? _dispatcherQueue;
 
     // When we transition from 0 online workspaces to >0 online workspaces, the
@@ -359,6 +361,22 @@ private void ShowFileSyncListWindow()
         _fileSyncListWindow.Activate();
     }
 
+    [RelayCommand]
+    private void ShowSettingsWindow()
+    {
+        // This is safe against concurrent access since it all happens in the
+        // UI thread.
+        if (_settingsWindow != null)
+        {
+            _settingsWindow.Activate();
+            return;
+        }
+
+        _settingsWindow = _services.GetRequiredService<SettingsWindow>();
+        _settingsWindow.Closed += (_, _) => _settingsWindow = null;
+        _settingsWindow.Activate();
+    }
+
     [RelayCommand]
     private async Task SignOut()
     {
diff --git a/App/Views/Pages/SettingsMainPage.xaml b/App/Views/Pages/SettingsMainPage.xaml
new file mode 100644
index 0000000..5ae7230
--- /dev/null
+++ b/App/Views/Pages/SettingsMainPage.xaml
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<Page
+    x:Class="Coder.Desktop.App.Views.Pages.SettingsMainPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:viewmodels="using:Coder.Desktop.App.ViewModels"
+    xmlns:converters="using:Coder.Desktop.App.Converters"
+    xmlns:ui="using:CommunityToolkit.WinUI"
+    xmlns:win="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:controls="using:CommunityToolkit.WinUI.Controls"
+    mc:Ignorable="d"
+    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+    <Page.Resources>
+        <!--  Spacing between cards  -->
+        <x:Double x:Key="SettingsCardSpacing">4</x:Double>
+        <!--  Style (inc. the correct spacing) of a section header  -->
+        <Style x:Key="SettingsSectionHeaderTextBlockStyle"
+               BasedOn="{StaticResource BodyStrongTextBlockStyle}"
+               TargetType="TextBlock">
+            <Style.Setters>
+                <Setter Property="Margin" Value="1,30,0,6" />
+            </Style.Setters>
+        </Style>
+    </Page.Resources>
+    <ScrollViewer>
+        <Grid Padding="20, 0, 20, 0">
+            <StackPanel MaxWidth="1000"
+                        HorizontalAlignment="Stretch"
+                        Spacing="{StaticResource SettingsCardSpacing}">
+                <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="Coder Desktop" />
+                <controls:SettingsCard Description="This setting controls whether the Coder Desktop app starts on Windows startup."
+                                       Header="Start on login"
+                                       HeaderIcon="{ui:FontIcon Glyph=&#xE819;}"
+                                       IsEnabled="{x:Bind ViewModel.StartOnLoginDisabled, Converter={StaticResource InverseBoolConverter}, Mode=OneWay}">
+                    <ToggleSwitch IsOn="{x:Bind ViewModel.StartOnLogin, Mode=TwoWay}" />
+                </controls:SettingsCard>
+                <TextBlock Style="{StaticResource SettingsSectionHeaderTextBlockStyle}" Text="Coder Connect" />
+                <controls:SettingsCard Description="This setting controls whether Coder Connect automatically starts with Coder Desktop. "
+                                       Header="Connect on launch"
+                                       HeaderIcon="{ui:FontIcon Glyph=&#xE8AF;}"
+                                       >
+                    <ToggleSwitch IsOn="{x:Bind ViewModel.ConnectOnLaunch, Mode=TwoWay}" />
+                </controls:SettingsCard>
+            </StackPanel>
+        </Grid>
+    </ScrollViewer>
+</Page>
diff --git a/App/Views/Pages/SettingsMainPage.xaml.cs b/App/Views/Pages/SettingsMainPage.xaml.cs
new file mode 100644
index 0000000..f2494b1
--- /dev/null
+++ b/App/Views/Pages/SettingsMainPage.xaml.cs
@@ -0,0 +1,15 @@
+using Coder.Desktop.App.ViewModels;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Coder.Desktop.App.Views.Pages;
+
+public sealed partial class SettingsMainPage : Page
+{
+    public SettingsViewModel ViewModel;
+
+    public SettingsMainPage(SettingsViewModel viewModel)
+    {
+        ViewModel = viewModel;
+        InitializeComponent();
+    }
+}
diff --git a/App/Views/Pages/TrayWindowLoginRequiredPage.xaml b/App/Views/Pages/TrayWindowLoginRequiredPage.xaml
index c1d69aa..171e292 100644
--- a/App/Views/Pages/TrayWindowLoginRequiredPage.xaml
+++ b/App/Views/Pages/TrayWindowLoginRequiredPage.xaml
@@ -36,7 +36,7 @@
         </HyperlinkButton>
 
         <HyperlinkButton
-            Command="{x:Bind ViewModel.ExitCommand, Mode=OneWay}"
+            Command="{x:Bind ViewModel.ExitCommand}"
             Margin="-12,-8,-12,-5"
             HorizontalAlignment="Stretch"
             HorizontalContentAlignment="Left"> 
diff --git a/App/Views/Pages/TrayWindowMainPage.xaml b/App/Views/Pages/TrayWindowMainPage.xaml
index 283867d..83ba29f 100644
--- a/App/Views/Pages/TrayWindowMainPage.xaml
+++ b/App/Views/Pages/TrayWindowMainPage.xaml
@@ -25,7 +25,7 @@
         Orientation="Vertical"
         HorizontalAlignment="Stretch"
         VerticalAlignment="Top"
-        Padding="20,20,20,30"
+        Padding="20,20,20,20"
         Spacing="10">
 
         <Grid>
@@ -331,9 +331,18 @@
 
         <controls:HorizontalRule />
 
+        <HyperlinkButton
+            Command="{x:Bind ViewModel.ShowSettingsWindowCommand, Mode=OneWay}"
+            Margin="-12,-4,-12,-4"
+            HorizontalAlignment="Stretch"
+            HorizontalContentAlignment="Left">
+
+            <TextBlock Text="Settings" Foreground="{ThemeResource DefaultTextForegroundThemeBrush}" />
+        </HyperlinkButton>
+
         <HyperlinkButton
             Command="{x:Bind ViewModel.SignOutCommand, Mode=OneWay}"
-            Margin="-12,0"
+            Margin="-12,-4,-12,-4"
             HorizontalAlignment="Stretch"
             HorizontalContentAlignment="Left">
 
@@ -342,7 +351,7 @@
 
         <HyperlinkButton
             Command="{x:Bind ViewModel.ExitCommand, Mode=OneWay}"
-            Margin="-12,-8,-12,-5"
+            Margin="-12,-4,-12,-4"
             HorizontalAlignment="Stretch"
             HorizontalContentAlignment="Left">          
 
diff --git a/App/Views/SettingsWindow.xaml b/App/Views/SettingsWindow.xaml
new file mode 100644
index 0000000..a84bbc4
--- /dev/null
+++ b/App/Views/SettingsWindow.xaml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<winuiex:WindowEx
+    x:Class="Coder.Desktop.App.Views.SettingsWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:winuiex="using:WinUIEx"
+    mc:Ignorable="d"
+    Title="Coder Settings"
+    Width="600" Height="350"
+    MinWidth="600" MinHeight="350">
+
+    <Window.SystemBackdrop>
+        <DesktopAcrylicBackdrop />
+    </Window.SystemBackdrop>
+
+    <Frame x:Name="RootFrame" />
+</winuiex:WindowEx>
diff --git a/App/Views/SettingsWindow.xaml.cs b/App/Views/SettingsWindow.xaml.cs
new file mode 100644
index 0000000..7cc9661
--- /dev/null
+++ b/App/Views/SettingsWindow.xaml.cs
@@ -0,0 +1,25 @@
+using Coder.Desktop.App.Utils;
+using Coder.Desktop.App.ViewModels;
+using Coder.Desktop.App.Views.Pages;
+using Microsoft.UI.Xaml.Media;
+using WinUIEx;
+
+namespace Coder.Desktop.App.Views;
+
+public sealed partial class SettingsWindow : WindowEx
+{
+    public readonly SettingsViewModel ViewModel;
+
+    public SettingsWindow(SettingsViewModel viewModel)
+    {
+        ViewModel = viewModel;
+        InitializeComponent();
+        TitleBarIcon.SetTitlebarIcon(this);
+
+        SystemBackdrop = new DesktopAcrylicBackdrop();
+
+        RootFrame.Content = new SettingsMainPage(ViewModel);
+
+        this.CenterOnScreen();
+    }
+}
diff --git a/App/packages.lock.json b/App/packages.lock.json
index a47908a..e442998 100644
--- a/App/packages.lock.json
+++ b/App/packages.lock.json
@@ -18,6 +18,16 @@
           "Microsoft.WindowsAppSDK": "1.6.250108002"
         }
       },
+      "CommunityToolkit.WinUI.Controls.SettingsControls": {
+        "type": "Direct",
+        "requested": "[8.2.250402, )",
+        "resolved": "8.2.250402",
+        "contentHash": "whJNIyxVwwLmmCS63m91r0aL13EYgdKDE0ERh2e0G2U5TUeYQQe2XRODGGr/ceBRvqu6SIvq1sXxVwglSMiJMg==",
+        "dependencies": {
+          "CommunityToolkit.WinUI.Triggers": "8.2.250402",
+          "Microsoft.WindowsAppSDK": "1.6.250108002"
+        }
+      },
       "CommunityToolkit.WinUI.Extensions": {
         "type": "Direct",
         "requested": "[8.2.250402, )",
@@ -152,6 +162,24 @@
         "resolved": "8.2.1",
         "contentHash": "LWuhy8cQKJ/MYcy3XafJ916U3gPH/YDvYoNGWyQWN11aiEKCZszzPOTJAOvBjP9yG8vHmIcCyPUt4L82OK47Iw=="
       },
+      "CommunityToolkit.WinUI.Helpers": {
+        "type": "Transitive",
+        "resolved": "8.2.250402",
+        "contentHash": "DThBXB4hT3/aJ7xFKQJw/C0ZEs1QhZL7QG6AFOYcpnGWNlv3tkF761PFtTyhpNQrR1AFfzml5zG+zWfFbKs6Mw==",
+        "dependencies": {
+          "CommunityToolkit.WinUI.Extensions": "8.2.250402",
+          "Microsoft.WindowsAppSDK": "1.6.250108002"
+        }
+      },
+      "CommunityToolkit.WinUI.Triggers": {
+        "type": "Transitive",
+        "resolved": "8.2.250402",
+        "contentHash": "laHIrBQkwQCurTNSQdGdEXUyoCpqY8QFXSybDM/Q1Ti/23xL+sRX/gHe3pP8uMM59bcwYbYlMRCbIaLnxnrdjw==",
+        "dependencies": {
+          "CommunityToolkit.WinUI.Helpers": "8.2.250402",
+          "Microsoft.WindowsAppSDK": "1.6.250108002"
+        }
+      },
       "Google.Protobuf": {
         "type": "Transitive",
         "resolved": "3.29.3",
diff --git a/Tests.App/Services/SettingsManagerTest.cs b/Tests.App/Services/SettingsManagerTest.cs
new file mode 100644
index 0000000..44f5c06
--- /dev/null
+++ b/Tests.App/Services/SettingsManagerTest.cs
@@ -0,0 +1,45 @@
+using Coder.Desktop.App.Models;
+using Coder.Desktop.App.Services;
+
+namespace Coder.Desktop.Tests.App.Services;
+[TestFixture]
+public sealed class SettingsManagerTests
+{
+    private string _tempDir = string.Empty;
+    private SettingsManager<CoderConnectSettings> _sut = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(_tempDir);
+        _sut = new SettingsManager<CoderConnectSettings>(_tempDir); // inject isolated path
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        try { Directory.Delete(_tempDir, true); } catch { /* ignore */ }
+    }
+
+    [Test]
+    public void Save_Persists()
+    {
+        var expected = true;
+        var settings = new CoderConnectSettings
+        {
+            Version = 1,
+            ConnectOnLaunch = expected
+        };
+        _sut.Write(settings).GetAwaiter().GetResult();
+        var actual = _sut.Read().GetAwaiter().GetResult();
+        Assert.That(actual.ConnectOnLaunch, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Read_MissingKey_ReturnsDefault()
+    {
+        var actual = _sut.Read().GetAwaiter().GetResult();
+        Assert.That(actual.ConnectOnLaunch, Is.False);
+    }
+}

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://patch-diff.githubusercontent.com/raw/coder/coder-desktop-windows/pull/113.diff" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://patch-diff.githubusercontent.com/raw/coder/coder-desktop-windows/pull/113.diff" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://patch-diff.githubusercontent.com/raw/coder/coder-desktop-windows/pull/113.diff" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://patch-diff.githubusercontent.com/raw/coder/coder-desktop-windows/pull/113.diff" target="_blank">pFad v4 Proxy</a></p></body>
</html>