diff --git a/ActiveDirectoryQuerier.Tests/ADCommandParametersTests.cs b/ActiveDirectoryQuerier.Tests/ADCommandParametersTests.cs
new file mode 100644
index 0000000..bb2cadd
--- /dev/null
+++ b/ActiveDirectoryQuerier.Tests/ADCommandParametersTests.cs
@@ -0,0 +1,48 @@
+using System.Management.Automation.Runspaces;
+using ActiveDirectoryQuerier.ActiveDirectory;
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+// ReSharper disable once InconsistentNaming
+public class ADCommandParametersTests
+{
+    [Fact]
+    public void AvailableParameters_AvailableParametersNotPopulated_NoValidCommandProvided()
+    {
+        // Arrange
+        ADCommandParameters adCommandParameters = new();
+
+        // Assert
+        Assert.Contains("No valid command provided", adCommandParameters.AvailableParameters);
+    }
+
+    [Fact]
+    public async Task LoadAvailableParametersAsync_PopulatesAvailableParameters_IsNotEmpty()
+    {
+        // Arrange
+        ADCommandParameters adCommandParameters = new();
+        Command command = new("Get-Process");
+
+        // Act
+        await adCommandParameters.LoadAvailableParametersAsync(command);
+
+        // Assert
+        Assert.NotEmpty(adCommandParameters.AvailableParameters);
+    }
+
+    [Fact]
+    public async Task LoadAvailableParametersAsync_CheckAvailableParameters_ContainsNameAndId()
+    {
+        // Arrange
+        ADCommandParameters adCommandParameters = new();
+        Command command = new("Get-Process");
+
+        // Act
+        await adCommandParameters.LoadAvailableParametersAsync(command);
+
+        // Assert
+        Assert.Contains("-Name", adCommandParameters.AvailableParameters);
+        Assert.Contains("-Id", adCommandParameters.AvailableParameters);
+    }
+}
diff --git a/ActiveDirectoryQuerier.Tests/ADCommandsFetcherTests.cs b/ActiveDirectoryQuerier.Tests/ADCommandsFetcherTests.cs
new file mode 100644
index 0000000..a5afd55
--- /dev/null
+++ b/ActiveDirectoryQuerier.Tests/ADCommandsFetcherTests.cs
@@ -0,0 +1,33 @@
+using System.Collections.ObjectModel;
+using System.Management.Automation.Runspaces;
+using ActiveDirectoryQuerier.ActiveDirectory;
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+// ReSharper disable once InconsistentNaming
+public class ADCommandsFetcherTests
+{
+    [Fact]
+    public async Task GetADCommands_ReturnsCommandList_IsNotEmpty()
+    {
+        // Act
+        ObservableCollection<Command> adCommands = await ADCommandsFetcher.GetADCommands();
+
+        // Assert
+        Assert.NotEmpty(adCommands);
+    }
+
+    [Theory]
+    [InlineData("Get-ADUser")]
+    [InlineData("Get-ADGroup")]
+    [InlineData("Get-ADComputer")]
+    public async Task GetADCommands_ReturnsCommandList_ContainsCommand(string commandName)
+    {
+        // Act
+        ObservableCollection<Command> adCommands = await ADCommandsFetcher.GetADCommands();
+
+        // Assert
+        Assert.Contains(adCommands, command => command.CommandText == commandName);
+    }
+}
diff --git a/ActiveDirectoryQuerier.Tests/ActiveDirectoryCommandsTests.cs b/ActiveDirectoryQuerier.Tests/ActiveDirectoryCommandsTests.cs
deleted file mode 100644
index 267c130..0000000
--- a/ActiveDirectoryQuerier.Tests/ActiveDirectoryCommandsTests.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System.Collections.ObjectModel;
-using System.Management.Automation.Runspaces;
-using ActiveDirectoryQuerier.PowerShell;
-
-namespace ActiveDirectoryQuerier.Tests;
-
-public class ActiveDirectoryCommandsTests
-{
-    [Fact]
-    public async Task GetActiveDirectoryCommands_ReturnsCommandList_IsNotEmpty()
-    {
-        // Act
-        ObservableCollection<Command> commandList = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
-
-        // Assert
-        Assert.NotEmpty(commandList);
-    }
-
-    [Theory]
-    [InlineData("Get-ADUser")]
-    [InlineData("Get-ADGroup")]
-    [InlineData("Get-ADComputer")]
-    public async Task GetActiveDirectoryCommands_ReturnsCommandList_ContainsCommand(string commandName)
-    {
-        // Act
-        ObservableCollection<Command> commandList = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
-
-        // Assert
-        Assert.Contains(commandList, cmd => cmd.CommandText == commandName);
-    }
-}
diff --git a/ActiveDirectoryQuerier.Tests/AppConsoleTests.cs b/ActiveDirectoryQuerier.Tests/AppConsoleTests.cs
new file mode 100644
index 0000000..22f00fa
--- /dev/null
+++ b/ActiveDirectoryQuerier.Tests/AppConsoleTests.cs
@@ -0,0 +1,83 @@
+using System.Management.Automation.Runspaces;
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+public class AppConsoleTests : IDisposable
+{
+    // TODO: Make sure this is how I should perform cleanups...
+    public void Dispose()
+    {
+        if (File.Exists("output.txt"))
+        {
+            File.Delete("output.txt");
+        }
+
+        if (File.Exists("output.csv"))
+        {
+            File.Delete("output.csv");
+        }
+
+        GC.SuppressFinalize(this);
+    }
+
+    private static async Task<(AppConsole, PSOutput)> ExecuteCommandAsync(Command command)
+    {
+        PSExecutor psExecutor = new();
+        AppConsole appConsole = new();
+        PSOutput result = await psExecutor.ExecuteAsync(command);
+
+        appConsole.Append(result.HadErrors ? result.StdErr : result.StdOut);
+
+        return (appConsole, result);
+    }
+
+    [Fact]
+    public async Task ClearConsole_ClearsConsole_SuccessfullyCleared()
+    {
+        // Arrange
+        Command command = new("Get-Process");
+        command.Parameters.Add("Name", "explorer");
+        var (appConsole, _) = await ExecuteCommandAsync(command);
+
+        // Act
+        appConsole.Clear();
+
+        // Assert
+        Assert.Empty(appConsole.ConsoleOutput);
+    }
+
+    [Fact]
+    public void Append_AppendsStringToConsole_SuccessfullyAppended()
+    {
+        // Arrange
+        AppConsole appConsole = new();
+        const string output = "Output";
+
+        // Act
+        appConsole.Append(output);
+
+        // Assert
+        Assert.Equal(output, appConsole.ConsoleOutput);
+    }
+
+    [Fact]
+    public async Task ExportToText_ExportToText_SuccessfullyExported()
+    {
+        // Arrange
+        Command command = new("Get-Process");
+        command.Parameters.Add("Name", "explorer");
+        var (appConsole, returnValues) = await ExecuteCommandAsync(command);
+
+        // Act
+        appConsole.ExportToText();
+        string fileContents = await File.ReadAllTextAsync("output.txt");
+
+        // Assert
+        Assert.True(File.Exists("output.txt"));
+
+        Assert.Equal(returnValues.HadErrors ? string.Join(Environment.NewLine, returnValues.StdErr)
+                                            : string.Join(Environment.NewLine, returnValues.StdOut),
+                     fileContents);
+    }
+}
diff --git a/ActiveDirectoryQuerier.Tests/ComboBoxParameterViewModelTests.cs b/ActiveDirectoryQuerier.Tests/ComboBoxParameterViewModelTests.cs
new file mode 100644
index 0000000..a98c571
--- /dev/null
+++ b/ActiveDirectoryQuerier.Tests/ComboBoxParameterViewModelTests.cs
@@ -0,0 +1,76 @@
+using System.Collections.ObjectModel;
+using System.Management.Automation.Runspaces;
+using ActiveDirectoryQuerier.ActiveDirectory;
+using ActiveDirectoryQuerier.PowerShell;
+using ActiveDirectoryQuerier.ViewModels;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+public class ComboBoxParameterViewModelTests
+{
+    [Fact]
+    public async Task ComboBoxParameterViewModel_WhenConstructed_PossibleParametersIsNotNullOrEmpty()
+    {
+        // Arrange
+        Command command = new("Get-ADUser");
+        ADCommandParameters adCommandParameters = new();
+        ComboBoxParameterViewModel comboBoxParameterViewModel;
+
+        // Act
+        await adCommandParameters.LoadAvailableParametersAsync(command);
+        comboBoxParameterViewModel = new(adCommandParameters.AvailableParameters);
+
+        // Assert
+        Assert.NotNull(comboBoxParameterViewModel.AvailableParameters);
+        Assert.NotEmpty(comboBoxParameterViewModel.AvailableParameters);
+    }
+
+    [Fact]
+    public async Task ComboBoxParameterViewModel_WhenConstructed_PossibleParametersContainsExpectedParameters()
+    {
+        // Arrange
+        Command command = new("Get-ADUser");
+        ADCommandParameters adCommandParameters = new();
+        ComboBoxParameterViewModel comboBoxParameterViewModel;
+
+        // Act
+        await adCommandParameters.LoadAvailableParametersAsync(command);
+        comboBoxParameterViewModel = new(adCommandParameters.AvailableParameters);
+
+        // Assert
+        Assert.Contains(comboBoxParameterViewModel.AvailableParameters, param => param == "-Filter");
+        Assert.Contains(comboBoxParameterViewModel.AvailableParameters, param => param == "-Identity");
+        Assert.Contains(comboBoxParameterViewModel.AvailableParameters, param => param == "-LDAPFilter");
+        Assert.Contains(comboBoxParameterViewModel.AvailableParameters, param => param == "-SearchBase");
+        Assert.Contains(comboBoxParameterViewModel.AvailableParameters, param => param == "-SearchScope");
+    }
+
+    [Fact]
+    public async Task ComboBoxParameterViewModel_WhenSelectedParameterChosen_SelectedParameterIsSet()
+    {
+        // Arrange
+        string selectedParameter;
+        Command command = new("Get-ADUser");
+        ADCommandParameters adCommandParameters = new();
+        ComboBoxParameterViewModel comboBoxParameterViewModel;
+
+        // Act
+        await adCommandParameters.LoadAvailableParametersAsync(command);
+        comboBoxParameterViewModel = new(adCommandParameters.AvailableParameters);
+        selectedParameter = comboBoxParameterViewModel.AvailableParameters[0];
+        comboBoxParameterViewModel.SelectedParameter = selectedParameter;
+
+        // Assert
+        Assert.Equal(selectedParameter, comboBoxParameterViewModel.SelectedParameter);
+    }
+
+    [Fact]
+    public void ComboBoxParameterViewModel_WhenConstructedWithNullPossibleParameters_ThrowsArgumentNullException()
+    {
+        // Arrange
+        ObservableCollection<string> possibleParameters = null!;
+
+        // Assert
+        Assert.Throws<ArgumentNullException>(() => new ComboBoxParameterViewModel(possibleParameters));
+    }
+}
diff --git a/ActiveDirectoryQuerier.Tests/CommandParametersTests.cs b/ActiveDirectoryQuerier.Tests/CommandParametersTests.cs
deleted file mode 100644
index aa749a2..0000000
--- a/ActiveDirectoryQuerier.Tests/CommandParametersTests.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Management.Automation.Runspaces;
-using ActiveDirectoryQuerier.PowerShell;
-
-namespace ActiveDirectoryQuerier.Tests;
-
-public class CommandParametersTests
-{
-    [Fact]
-    public void PossibleParameters_LoadCommandParametersAsyncNotPopulated_ThrowInvalidOperationException()
-    {
-        // Arrange
-        CommandParameters commandParameters = new();
-
-        // Assert
-        Assert.Throws<InvalidOperationException>(() => commandParameters.PossibleParameters);
-    }
-
-    [Fact]
-    public async Task LoadCommandParametersAsync_PopulatesPossibleParameters_IsNotEmpty()
-    {
-        // Arrange
-        CommandParameters commandParameters = new();
-        Command command = new("Get-Process");
-
-        // Act
-        await commandParameters.LoadCommandParametersAsync(command);
-
-        // Assert
-        Assert.NotEmpty(commandParameters.PossibleParameters);
-    }
-
-    [Fact]
-    public async Task LoadCommandParametersAsync_CheckPossibleParameter_ContentIsCorrect()
-    {
-        // Arrange
-        CommandParameters commandParameters = new();
-        Command command = new("Get-Process");
-
-        // Act
-        await commandParameters.LoadCommandParametersAsync(command);
-
-        // Assert
-        Assert.Contains("-Name", commandParameters.PossibleParameters);
-        Assert.Contains("-Id", commandParameters.PossibleParameters);
-    }
-}
diff --git a/ActiveDirectoryQuerier.Tests/PowerShellExecutorTests.cs b/ActiveDirectoryQuerier.Tests/PSExecutorTests.cs
similarity index 57%
rename from ActiveDirectoryQuerier.Tests/PowerShellExecutorTests.cs
rename to ActiveDirectoryQuerier.Tests/PSExecutorTests.cs
index 24c8828..ae5f78b 100644
--- a/ActiveDirectoryQuerier.Tests/PowerShellExecutorTests.cs
+++ b/ActiveDirectoryQuerier.Tests/PSExecutorTests.cs
@@ -3,20 +3,23 @@
 
 namespace ActiveDirectoryQuerier.Tests;
 
-public class PowerShellExecutorTests
+// ReSharper disable once InconsistentNaming
+public class PSExecutorTests
 {
     [Theory]
     [InlineData("Get-Command", "Module", "ActiveDirectory")]
     [InlineData("Get-Process", "Name", "explorer")]
-    public void Execute_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd, string paramName, string paramValue)
+    public void Execute_WhenGivenValidCommand_ReturnsExpectedOutput(string command,
+                                                                    string parameter,
+                                                                    string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
-        PowerShellExecutor powerShellExecutor = new();
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
+        PSExecutor psExecutor = new();
 
         // Act
-        ReturnValues result = powerShellExecutor.Execute(command);
+        PSOutput result = psExecutor.Execute(psCommand);
 
         // Assert
         Assert.False(result.HadErrors);
@@ -32,11 +35,11 @@ public void Execute_CheckIfOutputChanged_ReturnsDifferentOutput()
         command.Parameters.Add("Module", "ActiveDirectory");
         Command command2 = new("Get-Process");
         command.Parameters.Add("Name", "explorer");
-        PowerShellExecutor powerShellExecutor = new();
+        PSExecutor psExecutor = new();
 
         // Act
-        ReturnValues result = powerShellExecutor.Execute(command);
-        ReturnValues result2 = powerShellExecutor.Execute(command2);
+        PSOutput result = psExecutor.Execute(command);
+        PSOutput result2 = psExecutor.Execute(command2);
 
         // Assert
         Assert.NotEqual(result, result2);
@@ -45,17 +48,17 @@ public void Execute_CheckIfOutputChanged_ReturnsDifferentOutput()
     [Theory]
     [InlineData("Get-Command", "Module", "ActiveDirectory")]
     [InlineData("Get-Process", "Name", "explorer")]
-    public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(string cmd,
-                                                                               string paramName,
-                                                                               string paramValue)
+    public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(string command,
+                                                                               string parameter,
+                                                                               string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
-        PowerShellExecutor powerShellExecutor = new();
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
+        PSExecutor psExecutor = new();
 
         // Act
-        ReturnValues result = await powerShellExecutor.ExecuteAsync(command);
+        PSOutput result = await psExecutor.ExecuteAsync(psCommand);
 
         // Assert
         Assert.False(result.HadErrors);
@@ -66,15 +69,17 @@ public async Task ExecuteAsync_WhenGivenValidCommand_ReturnsExpectedOutput(strin
     [Theory]
     [InlineData("Get-ADUser", "InvalidParameter", "*")]
     [InlineData("InvalidCommand", "Filter", "*")]
-    public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd, string paramName, string paramValue)
+    public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string command,
+                                                                      string parameter,
+                                                                      string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
-        PowerShellExecutor powerShellExecutor = new();
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
+        PSExecutor psExecutor = new();
 
         // Act
-        ReturnValues result = powerShellExecutor.Execute(command);
+        PSOutput result = psExecutor.Execute(psCommand);
 
         // Assert
         Assert.True(result.HadErrors);
@@ -85,17 +90,17 @@ public void Execute_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd, st
     [Theory]
     [InlineData("Get-ADUser", "InvalidParameter", "*")]
     [InlineData("InvalidCommand", "Filter", "*")]
-    public async Task ExecuteAsync_WhenGivenInvalidCommand_ReturnsExpectedOutput(string cmd,
-                                                                                 string paramName,
-                                                                                 string paramValue)
+    public async Task ExecuteAsync_WhenGivenInvalidCommand_ReturnsExpectedOutput(string command,
+                                                                                 string parameter,
+                                                                                 string parameterValue)
     {
         // Arrange
-        Command command = new(cmd);
-        command.Parameters.Add(paramName, paramValue);
-        PowerShellExecutor powerShellExecutor = new();
+        Command psCommand = new(command);
+        psCommand.Parameters.Add(parameter, parameterValue);
+        PSExecutor psExecutor = new();
 
         // Act
-        ReturnValues result = await powerShellExecutor.ExecuteAsync(command);
+        PSOutput result = await psExecutor.ExecuteAsync(psCommand);
 
         // Assert
         Assert.True(result.HadErrors);
diff --git a/ActiveDirectoryQuerier.Tests/PSOutputTest.cs b/ActiveDirectoryQuerier.Tests/PSOutputTest.cs
new file mode 100644
index 0000000..dccddf1
--- /dev/null
+++ b/ActiveDirectoryQuerier.Tests/PSOutputTest.cs
@@ -0,0 +1,39 @@
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+// ReSharper disable once InconsistentNaming
+public class PSOutputTest
+{
+    [Fact]
+    public void HadErrors_StdErrHasEntries_ReturnsTrue()
+    {
+        // Arrange
+        PSOutput psOutput = new();
+        psOutput.StdErr.Add("Error");
+
+        // Act
+        bool result = psOutput.HadErrors;
+
+        // Assert
+        Assert.True(result);
+        Assert.NotEmpty(psOutput.StdErr);
+        Assert.Empty(psOutput.StdOut);
+    }
+
+    [Fact]
+    public void NoErrors_StdOutHasEntries_ReturnsFalse()
+    {
+        // Arrange
+        PSOutput psOutput = new();
+        psOutput.StdOut.Add("Output");
+
+        // Act
+        var result = psOutput.HadErrors;
+
+        // Assert
+        Assert.False(result);
+        Assert.Empty(psOutput.StdErr);
+        Assert.NotEmpty(psOutput.StdOut);
+    }
+}
diff --git a/ActiveDirectoryQuerier.Tests/RelayCommandTests.cs b/ActiveDirectoryQuerier.Tests/RelayCommandTests.cs
index b44ba75..bb4439c 100644
--- a/ActiveDirectoryQuerier.Tests/RelayCommandTests.cs
+++ b/ActiveDirectoryQuerier.Tests/RelayCommandTests.cs
@@ -1,4 +1,6 @@
-namespace ActiveDirectoryQuerier.Tests;
+using ActiveDirectoryQuerier.ViewModels;
+
+namespace ActiveDirectoryQuerier.Tests;
 
 public class RelayCommandTests
 {
diff --git a/ActiveDirectoryQuerier.Tests/ReturnValuesTest.cs b/ActiveDirectoryQuerier.Tests/ReturnValuesTest.cs
deleted file mode 100644
index 7e75175..0000000
--- a/ActiveDirectoryQuerier.Tests/ReturnValuesTest.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using ActiveDirectoryQuerier.PowerShell;
-
-namespace ActiveDirectoryQuerier.Tests;
-
-public class ReturnValuesTest
-{
-    [Fact]
-    public void HadErrors_StdErrHasEntries_ReturnsTrue()
-    {
-        // Arrange
-        var returnValues = new ReturnValues();
-        returnValues.StdErr.Add("Error");
-
-        // Act
-        var result = returnValues.HadErrors;
-
-        // Assert
-        Assert.True(result);
-        Assert.NotEmpty(returnValues.StdErr);
-        Assert.Empty(returnValues.StdOut);
-    }
-
-    [Fact]
-    public void NoErrors_StdOutHasEntries_ReturnsFalse()
-    {
-        // Arrange
-        var returnValues = new ReturnValues();
-        returnValues.StdOut.Add("Output");
-
-        // Act
-        var result = returnValues.HadErrors;
-
-        // Assert
-        Assert.False(result);
-        Assert.Empty(returnValues.StdErr);
-        Assert.NotEmpty(returnValues.StdOut);
-    }
-}
diff --git a/ActiveDirectoryQuerier.Tests/TextBoxViewModelTests.cs b/ActiveDirectoryQuerier.Tests/TextBoxViewModelTests.cs
new file mode 100644
index 0000000..87aa8f4
--- /dev/null
+++ b/ActiveDirectoryQuerier.Tests/TextBoxViewModelTests.cs
@@ -0,0 +1,31 @@
+using ActiveDirectoryQuerier.ViewModels;
+
+namespace ActiveDirectoryQuerier.Tests;
+
+public class TextBoxViewModelTests
+{
+    [Fact]
+    public void TextBoxViewModel_WhenConstructed_SelectedParameterValueIsNotNullOrEmpty()
+    {
+        // Arrange
+        TextBoxViewModel textBoxViewModel = new() {// Act
+                                                   SelectedParameterValue = "*"
+        };
+
+        // Assert
+        Assert.NotNull(textBoxViewModel.SelectedParameterValue);
+        Assert.NotEmpty(textBoxViewModel.SelectedParameterValue);
+    }
+
+    [Fact]
+    public void TextBoxViewModel_WhenSetToNull_NoExceptionIsThrown()
+    {
+        // Arrange
+        TextBoxViewModel textBoxViewModel = new() {// Act
+                                                   SelectedParameterValue = null!
+        };
+
+        // Assert
+        Assert.Null(textBoxViewModel.SelectedParameterValue);
+    }
+}
diff --git a/ActiveDirectoryQuerier/ActiveDirectory/ADCommandParameters.cs b/ActiveDirectoryQuerier/ActiveDirectory/ADCommandParameters.cs
new file mode 100644
index 0000000..2b5b107
--- /dev/null
+++ b/ActiveDirectoryQuerier/ActiveDirectory/ADCommandParameters.cs
@@ -0,0 +1,82 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Management.Automation;
+using System.Management.Automation.Runspaces;
+
+namespace ActiveDirectoryQuerier.ActiveDirectory;
+
+// ReSharper disable once InconsistentNaming
+public class ADCommandParameters
+{
+    private readonly ObservableCollection<string> _availableParameters = new();
+
+    /// <summary></summary>
+    /// <important>
+    /// This property should not be accessed before LoadAvailableParametersAsync or LoadAvailableParameters has been
+    /// called. If it is accessed before either method has been called, no parameters will be available.
+    /// </important>
+    public ObservableCollection<string> AvailableParameters
+    {
+        get {
+            if (_availableParameters.Count == 0)
+            {
+                Debug.WriteLine("Warning: LoadAvailableParametersAsync should be called before accessing " +
+                                "AvailableParameters, to ensure asynchronous loading of parameters.");
+                LoadAvailableParameters(null);
+            }
+
+            return _availableParameters;
+        }
+    }
+
+    public async Task LoadAvailableParametersAsync(Command? psCommand)
+    {
+        await LoadAvailableParametersCore(psCommand, true);
+    }
+
+    public void LoadAvailableParameters(Command? psCommand)
+    {
+        LoadAvailableParametersCore(psCommand, false).Wait();
+    }
+
+    private async Task LoadAvailableParametersCore(Command? psCommand, bool isAsync)
+    {
+        // psCommand can be null if the user attempts to select an ActiveDirectory command that doesn't exist.
+        // More specifically, if the entered command doesn't exist in the ADCommands property defined in
+        // MainWindowViewModel.cs, psCommand will be null, causing an exception to be thrown, crashing the
+        // program.
+        if (psCommand is null)
+        {
+            Trace.WriteLine("Error: command is null");
+            _availableParameters.Add("No valid command provided");
+            return;
+        }
+
+        if (_availableParameters.Count == 0)
+        {
+            using var powerShell = System.Management.Automation.PowerShell.Create();
+            string commandString =
+                $"Get-Command {psCommand.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{ $_.Keys }}";
+
+            powerShell.Commands.Clear();
+            powerShell.AddScript(commandString);
+
+            if (isAsync)
+            {
+                PSDataCollection<PSObject> result = await powerShell.InvokeAsync();
+                foreach (PSObject adCommandParameter in result)
+                {
+                    _availableParameters.Add($"-{adCommandParameter}");
+                }
+            }
+            else
+            {
+                Collection<PSObject> result = powerShell.Invoke();
+                foreach (PSObject adCommandParameter in result)
+                {
+                    _availableParameters.Add($"-{adCommandParameter}");
+                }
+            }
+        }
+    }
+}
diff --git a/ActiveDirectoryQuerier/ActiveDirectory/ADCommandsFetcher.cs b/ActiveDirectoryQuerier/ActiveDirectory/ADCommandsFetcher.cs
new file mode 100644
index 0000000..6ab5746
--- /dev/null
+++ b/ActiveDirectoryQuerier/ActiveDirectory/ADCommandsFetcher.cs
@@ -0,0 +1,38 @@
+using System.Collections.ObjectModel;
+using System.Management.Automation;
+using System.Management.Automation.Runspaces;
+using System.Windows;
+using ActiveDirectoryQuerier.PowerShell;
+
+namespace ActiveDirectoryQuerier.ActiveDirectory;
+
+// ReSharper disable once InconsistentNaming
+public static class ADCommandsFetcher
+{
+    // ReSharper disable once InconsistentNaming
+    public static async Task<ObservableCollection<Command>> GetADCommands()
+    {
+        Command psCommand = new("Get-Command");
+        psCommand.Parameters.Add("Module", "ActiveDirectory");
+        PSExecutor psExecutor = new();
+        ObservableCollection<Command> adCommands = new();
+        PSOutput psOutput = await psExecutor.ExecuteAsync(psCommand);
+
+        // This is more of an internal error catch, as even through this command shouldn't fail, it's possible that it
+        // could. If this is the case, we want to know about it.
+        if (psOutput.HadErrors)
+        {
+            string errorMessage = "Internal Error: An error occurred while retrieving the Active Directory commands: " +
+                                  $"({string.Join(" ", psOutput.StdErr)})";
+            MessageBox.Show(errorMessage, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
+            throw new InvalidPowerShellStateException(errorMessage);
+        }
+
+        foreach (string command in psOutput.StdOut)
+        {
+            adCommands.Add(new Command(command));
+        }
+
+        return adCommands;
+    }
+}
diff --git a/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj b/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj
index 1efb6dd..403bbb6 100644
--- a/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj
+++ b/ActiveDirectoryQuerier/ActiveDirectoryQuerier.csproj
@@ -9,9 +9,9 @@
 
 		<!-- Project Info. -->
 		<Title>Active Directory Querier</Title>
-		<Version>0.5.0</Version>
+		<Version>0.6.0</Version>
 		<Authors>Hunter T., Pieter, Joseph</Authors>
-		<RepositoryUrl>https://github.com/StrangeRanger/FAFB-PowerShell-Tool</RepositoryUrl>
+		<RepositoryUrl>https://github.com/StrangeRanger/Active-Directory-Querier</RepositoryUrl>
 
 		<!-- Project Compile Time Settings. -->
 		<PublishSingleFile>false</PublishSingleFile>
diff --git a/ActiveDirectoryQuerier/AppConsole.cs b/ActiveDirectoryQuerier/AppConsole.cs
new file mode 100644
index 0000000..0c0caba
--- /dev/null
+++ b/ActiveDirectoryQuerier/AppConsole.cs
@@ -0,0 +1,53 @@
+using System.ComponentModel;
+using System.IO;
+
+namespace ActiveDirectoryQuerier;
+
+public sealed class AppConsole : INotifyPropertyChanged
+{
+    public event PropertyChangedEventHandler? PropertyChanged;
+    private string _consoleOutput = string.Empty;
+
+    /// <summary></summary>
+    /// <important>
+    /// Do not set this property directly. Use the Append method instead. It's public for data binding purposes.
+    /// </important>
+    /// TODO: Find a way to make the set of this property private, while still allowing data binding.
+    public string ConsoleOutput
+    {
+        get => _consoleOutput;
+    [EditorBrowsable(EditorBrowsableState.Never)]
+        set {
+            if (_consoleOutput != value)
+            {
+                _consoleOutput = value;
+                OnPropertyChanged(nameof(ConsoleOutput));
+            }
+        }
+    }
+
+    public void Clear()
+    {
+        ConsoleOutput = string.Empty;
+    }
+
+    public void Append(List<string> outputText)
+    {
+        ConsoleOutput += string.Join(Environment.NewLine, outputText);
+    }
+
+    public void Append(string outputText)
+    {
+        ConsoleOutput += outputText;
+    }
+
+    public void ExportToText(string filePath = "output.txt")
+    {
+        File.WriteAllText(filePath, ConsoleOutput);
+    }
+
+    private void OnPropertyChanged(string propertyName)
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/ActiveDirectoryQuerier/ComboBoxParameterViewModel.cs b/ActiveDirectoryQuerier/ComboBoxParameterViewModel.cs
deleted file mode 100644
index b9c800e..0000000
--- a/ActiveDirectoryQuerier/ComboBoxParameterViewModel.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-using System.Collections.ObjectModel;
-using System.ComponentModel;
-
-namespace ActiveDirectoryQuerier;
-
-/// <summary>
-/// ViewModel for a ComboBox that displays possible parameters for a PowerShell command.
-/// It is used when adding a new parameter slot to a command in the UI.
-/// </summary>
-public sealed class ComboBoxParameterViewModel : INotifyPropertyChanged
-{
-    public event PropertyChangedEventHandler? PropertyChanged;
-    private ObservableCollection<string> _possibleParameterList = new();
-    private string _selectedParameter = string.Empty;
-
-    /// <summary>
-    /// Initializes a new instance of the ComboBoxParameterViewModel class.
-    /// </summary>
-    /// <param name="possibleParameterList">Initial list of possible parameters for the ComboBox.</param>
-    public ComboBoxParameterViewModel(ObservableCollection<string> possibleParameterList)
-    {
-        PossibleParameterList = possibleParameterList ?? throw new ArgumentNullException(nameof(possibleParameterList));
-    }
-
-    /// <summary>
-    /// Sets a unique selected value for each combo box.
-    /// </summary>
-    public string SelectedParameter
-    {
-        get => _selectedParameter;
-        set {
-            if (_selectedParameter != value)
-            {
-                _selectedParameter = value;
-                OnPropertyChanged(nameof(SelectedParameter));
-            }
-        }
-    }
-
-    /// <summary>
-    /// Gets or sets the list of possible parameters that can be selected for a command.
-    /// </summary>
-    public ObservableCollection<string> PossibleParameterList
-    {
-        get => _possibleParameterList;
-        set {
-            if (value is null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
-            if (_possibleParameterList != value)
-            {
-                _possibleParameterList = value;
-                OnPropertyChanged(nameof(PossibleParameterList));
-            }
-        }
-    }
-
-    /// <summary>
-    /// Invokes the PropertyChanged event for the specified property name.
-    /// </summary>
-    /// <param name="propertyName">Name of the property that has changed.</param>
-    private void OnPropertyChanged(string propertyName)
-    {
-        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
-    }
-}
diff --git a/ActiveDirectoryQuerier/MainWindow.xaml b/ActiveDirectoryQuerier/MainWindow.xaml
index 7a62e8f..07c52f0 100644
--- a/ActiveDirectoryQuerier/MainWindow.xaml
+++ b/ActiveDirectoryQuerier/MainWindow.xaml
@@ -1,4 +1,4 @@
-<Window x:Class="ActiveDirectoryQuerier.MainWindow"
+<Window x:Class="ActiveDirectoryQuerier.MainWindow"
         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"
@@ -9,47 +9,48 @@
     <Window.DataContext>
         <activeDirectoryQuerier:MainWindowViewModel />
     </Window.DataContext>
-
     <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="93*"/>
+            <ColumnDefinition Width="547*"/>
+        </Grid.ColumnDefinitions>
         <!-- Define Columns. -->
-        <!--<Grid.ColumnDefinitions>
-            <ColumnDefinition Width="119*"/>
-            <ColumnDefinition Width="681*"/>
-        </Grid.ColumnDefinitions>-->
-
+        <!--<Grid.ColumnDefinitions><ColumnDefinition Width="119*"/><ColumnDefinition Width="681*"/></Grid.ColumnDefinitions>-->
         <!-- Define Rows. -->
         <Grid.RowDefinitions>
             <RowDefinition Height="Auto" />
             <RowDefinition Height="*" />
         </Grid.RowDefinitions>
-
         <!-- Static Header Bar. -->
-        <Border Grid.Row="0" Grid.Column="0" Background="DarkGray" Height="42"/>
-
+        <Border Grid.Row="0" Background="DarkGray" Height="42" Grid.ColumnSpan="2" >
+            <Menu Width="50" Height="20" HorizontalAlignment="Left" VerticalAlignment="Top">
+                <MenuItem Header="File"  Width="Auto" Height="Auto" >
+                    <MenuItem Header="Import Queries" Command="{Binding ImportQueryFileRelay}"/>
+                    <MenuItem Header="New Query File" Command="{Binding CreateNewQueryFileRelay}" />
+                </MenuItem>
+            </Menu>
+        </Border>
         <!-- Grid for resizable content. -->
-        <Grid Grid.Row="1">
+        <Grid Grid.Row="1" Grid.ColumnSpan="2">
             <!-- Define Columns for resizable area. -->
             <Grid.ColumnDefinitions>
-                <ColumnDefinition Width="250" MinWidth="200"/>
-                <ColumnDefinition Width="Auto"/>
-                <ColumnDefinition Width="3*" MinWidth="400"/>
+                <ColumnDefinition Width="250" MinWidth="200" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="3*" MinWidth="400" />
             </Grid.ColumnDefinitions>
-
             <!-- Left Side Query Bar (Content in first column) -->
-            <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
-                <Grid x:Name="LeftSideQueryGrid" Grid.Column="0">
+            <ScrollViewer Grid.Column="0" VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Auto">
+                <Grid>
                     <Grid.BindingGroup>
-                        <BindingGroup/>
+                        <BindingGroup />
                     </Grid.BindingGroup>
-
                     <Grid.Background>
                         <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
-                            <GradientStop Color="#FF616161" Offset="0"/>
-                            <GradientStop Color="#FF5F5F5F" Offset="0.363"/>
-                            <GradientStop Color="#FF898989" Offset="0.737"/>
+                            <GradientStop Color="#FF616161" Offset="0" />
+                            <GradientStop Color="#FF5F5F5F" Offset="0.363" />
+                            <GradientStop Color="#FF898989" Offset="0.737" />
                         </LinearGradientBrush>
                     </Grid.Background>
-
                     <!-- Stacked Queries are placed here. -->
                     <ItemsControl ItemsSource="{Binding QueryButtonStackPanel}">
                         <ItemsControl.ItemTemplate>
@@ -60,10 +61,8 @@
                     </ItemsControl>
                 </Grid>
             </ScrollViewer>
-
             <!-- Grid Splitter for resizing. -->
             <GridSplitter Grid.Column="1" Width="5" HorizontalAlignment="Center" Background="Gray" />
-
             <!-- TabControl Grid (Content in third column). -->
             <Grid Background="White" Grid.Column="2">
                 <!-- Query Information Tab Control. -->
@@ -71,15 +70,32 @@
                     <TabItem Header="Query Information">
                         <Grid Background="#FFE5E5E5">
                             <Grid.ColumnDefinitions>
-                                <ColumnDefinition Width="163*"/>
-                                <ColumnDefinition Width="856*"/>
+                                <ColumnDefinition Width="*" />
+                                <ColumnDefinition Width="*" />
                             </Grid.ColumnDefinitions>
-                            <!-- Query Name TextBox.TODO: add a title/header to them  -->
-                            <TextBox Text="{Binding QueryName}" Margin="10,29,10,0" TextWrapping="Wrap" VerticalAlignment="Top" Height="50" Grid.ColumnSpan="2"/>
-                            <RichTextBox Margin="10,108,10,200" Grid.ColumnSpan="2">
+                            <Grid.RowDefinitions>
+                                <RowDefinition MinHeight="130" MaxHeight="60" Height="*"/>
+                                <RowDefinition MinHeight="130" MaxHeight="60" Height="*" />
+                            </Grid.RowDefinitions>
+                            <!-- Query Name TextBox. -->
+                            <TextBlock Grid.Row="0" HorizontalAlignment="Left" Margin="20,10" FontWeight="Bold">Query Name</TextBlock>
+                            <TextBox  Grid.Column="0" 
+                                      Grid.ColumnSpan="2" 
+                                      Text="{Binding QueryName}" 
+                                      TextWrapping="Wrap" 
+                                      VerticalAlignment="Center" 
+                                      Height="50"
+                                      Margin="20,0,20,0"/>
+                            <!-- Query Description RichTextBox -->
+                            <TextBlock FontWeight="Bold" HorizontalAlignment="Left" Margin="20,3" Grid.Row="1">Query Description</TextBlock>
+                            <RichTextBox Grid.Row="1" 
+                                         Grid.Column="0"  
+                                         Grid.ColumnSpan="2" 
+                                         HorizontalAlignment="Center"
+                                         Margin="20,28,20,10" >
                                 <FlowDocument>
                                     <Paragraph>
-                                        <Run Text="{Binding QueryDescription}"/>
+                                        <Run Text="{Binding QueryDescription}" />
                                     </Paragraph>
                                 </FlowDocument>
                             </RichTextBox>
@@ -90,32 +106,38 @@
                         <Grid Background="#FFE5E5E5">
                             <!-- Define Rows. -->
                             <Grid.RowDefinitions>
-                                <!-- TODO: Figure out why the bottom row isn't stopping at the specified min height!!! -->
-                                <RowDefinition Height="Auto" MinHeight="100"/>
-                                <RowDefinition Height="Auto"/>
-                                <RowDefinition Height="5"/>
-                                <RowDefinition Height="3*" MinHeight="100"/>
+                                <RowDefinition Height="Auto" MinHeight="140" />
+                                <RowDefinition MinHeight="100" />
                             </Grid.RowDefinitions>
-                            <!-- TODO: Fix the margin so that the combo boxes are not so spaced-->
-                            <Grid Grid.Row="0" Grid.ColumnSpan="3" Margin="0,0,0,100" Grid.RowSpan="2">
+                            <!-- ROW 0 START -->
+                            <Grid Margin="0,0,0,49" Grid.Row="0">
                                 <Grid.ColumnDefinitions>
-                                    <ColumnDefinition Width="*"/>
-                                    <ColumnDefinition Width="*"/>
-                                    <ColumnDefinition Width="Auto"/>
+                                    <ColumnDefinition Width="*" />
+                                    <ColumnDefinition Width="*" />
+                                    <ColumnDefinition Width="*" />
                                 </Grid.ColumnDefinitions>
-
-                                <ComboBox ItemsSource="{Binding ActiveDirectoryCommandsList}" 
-                                              SelectedItem="{Binding SelectedComboBoxCommand}"
-                                              DisplayMemberPath="CommandText" 
-                                              HorizontalAlignment="Center" 
-                                              VerticalAlignment="Center" 
-                                              Width="212"  
-                                              IsEditable="True"
-                                              Grid.Column="0"/>
+                                <Grid.RowDefinitions>
+                                    <RowDefinition Height="*" />
+                                    <RowDefinition Height="*" />
+                                    <RowDefinition Height="*" />
+                                </Grid.RowDefinitions>
+                                <!-- TODO: Pieter refer to here regarding combobox setup -->
+                                <TextBlock Grid.Row="0" Grid.Column="0" FontWeight="Bold" HorizontalAlignment="Center">Command</TextBlock>
+                                <ComboBox ItemsSource="{Binding ADCommands}"
+                                          SelectedItem="{Binding SelectedCommandFromComboBoxInQueryBuilder}"
+                                          DisplayMemberPath="CommandText"
+                                          HorizontalAlignment="Center"
+                                          VerticalAlignment="Center"
+                                          Width="212"
+                                          IsEditable="True"
+                                          Grid.Column="0"
+                                          Grid.Row="1" />
 
                                 <!-- ItemsControl for Dynamic ComboBoxes -->
-                                <ItemsControl ItemsSource="{Binding DynamicParametersCollection}"
-                                              Grid.Column="1">
+                                <TextBlock Grid.Row="0" Grid.Column="1" FontWeight="Bold" HorizontalAlignment="Left">Parameter</TextBlock>
+                                <ItemsControl ItemsSource="{Binding DynamicallyAvailableADCommandParametersComboBox}"
+                                              Grid.Column="1"
+                                              Grid.Row="1">
                                     <ItemsControl.ItemTemplate>
                                         <DataTemplate>
                                             <ComboBox Width="212"
@@ -123,126 +145,90 @@
                                                       HorizontalAlignment="Left"
                                                       VerticalAlignment="Center"
                                                       Margin="5"
-                                                      ItemsSource="{Binding PossibleParameterList}"
-                                                      SelectedItem="{Binding SelectedParameter}"
-                                                      />
+                                                      ItemsSource="{Binding AvailableParameters}"
+                                                      SelectedItem="{Binding SelectedParameter}" />
                                         </DataTemplate>
                                     </ItemsControl.ItemTemplate>
                                 </ItemsControl>
-                                <!-- TODO: Fill these-->
-                                <ItemsControl ItemsSource="{Binding DynamicParameterValuesCollection}"
-                                              Grid.Column="2">
+
+                                <!-- Parameter Values ComboBox -->
+                                <TextBlock Grid.Row="0" Grid.Column="2" FontWeight="Bold" HorizontalAlignment="Left">Value</TextBlock>
+                                <ItemsControl ItemsSource="{Binding DynamicallyAvailableADCommandParameterValueTextBox}"
+                                              Grid.Column="2"
+                                              Grid.Row="1">
                                     <ItemsControl.ItemTemplate>
                                         <DataTemplate>
                                             <TextBox Width="212"
                                                      HorizontalAlignment="Left"
                                                      VerticalAlignment="Center"
                                                      Margin="5"
-                                                     Text="{Binding SelectedParameterValue}"
-                                                     />
+                                                     Text="{Binding SelectedParameterValue, UpdateSourceTrigger=PropertyChanged}" />
                                         </DataTemplate>
                                     </ItemsControl.ItemTemplate>
                                 </ItemsControl>
-                            </Grid>
-
-                            <Grid Grid.Row="1" Margin="12,16,12,16">
-                                <Grid.ColumnDefinitions>
-                                    <ColumnDefinition Width="*" />
-                                    <ColumnDefinition Width="*" />
-                                    <ColumnDefinition Width="*" />
-                                    <ColumnDefinition Width="*" />
-                                    <ColumnDefinition Width="*" />
-                                    <ColumnDefinition Width="*" />
-                                    <ColumnDefinition Width="*" />
-                                </Grid.ColumnDefinitions>
-
-
-                                <Button Content="Add New Command Slot"
-                                        Command="{Binding AddCommandComboBoxRelay}"
-                                        Grid.Column="0"/>
-                                <Button Content="Add New Parameter Slot"
-                                        Command="{Binding AddParameterComboBoxRelay}"
-                                        Grid.Column="1"/>
-                                <Button Content="Remove Parameter Slot"
-                                        Command="{Binding RemoveParameterComboBoxRelay}"
-                                        Grid.Column="2"
-                                        />
-
-                                <Button x:Name="SaveQueryButton"
-                                            Content="Save Query"
-                                            Command="{Binding SaveCustomQueriesRelay}"
-                                            Grid.Column="3" />
-                                <Button Content="Execute"
-                                            Command="{Binding ExecuteCommandRelay}"
-                                            Grid.Column="4" />
-                                <Button Content="Export Console Output"
-                                        Command="{Binding ExportConsoleOutput}"
-                                        Grid.Column="5" />
-                                <Button Content="Clear Console Output"
-                                        Command="{Binding ClearConsoleOutput}"
-                                        Grid.Column="6" />
-                            </Grid>
-
-                            <!-- GridSplitter for resizing console area in the second row -->
-                            <GridSplitter Height="5" HorizontalAlignment="Stretch" VerticalAlignment="Center" Background="White" Grid.Row="2" Grid.ColumnSpan="2"/>
-
-                            <!-- TODO: Figure out why I can't get the console to be resizable to the min height... -->
-                            <Grid Grid.Row="3" Grid.ColumnSpan="2">
-                                <!-- TextBox as Console Output -->
-                                <TextBox Text="{Binding PowerShellOutput}" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Margin="10" IsReadOnly="True" TextWrapping="Wrap" VerticalScrollBarVisibility="Auto"/>
-                            </Grid>
-                            <!-- Menu options  -->
-                            <Menu Grid.Row="0" x:Name="OptionsMenu" Width="Auto" Height="20" Margin="10,15,934,64">
-                                <MenuItem Header="Options">
-                                    <MenuItem Header="Add New Command Slot"
-                                              Command="{Binding AddCommandComboBoxRelay}"
-                                              />
-                                    <MenuItem Header="Add New Parameter Slot"
-                                              Command="{Binding AddParameterComboBoxRelay}"
-                                              />
-                                    <MenuItem Header="Remove Parameter Slot"
-                                              Command="{Binding RemoveParameterComboBoxRelay}"
-                                              />
-                                    <MenuItem Header="Save Query"
-                                              Command="{Binding SaveCustomQueriesRelay}"
-                                              />
-                                    <MenuItem Header="Execute"
-                                              Command="{Binding ExecuteCommandRelay}"
-                                              >
-                                        <MenuItem Header="Output to console"
-                                                  Command="{Binding ExecuteCommandRelay}"
-                                                  />
-                                        <MenuItem Header="Output to Csv"
-                                                  Command="{Binding OutputToCsvFileRelay}"/>
-                                        <MenuItem Header="Output to Text"
-                                                  Command="{Binding OutputToTextFileRelay}"/>
+                                <!-- END of Dynamic ComboxBoxes for parameters and values-->
+
+                                <!-- START of Button ComboBox -->
+                                <Menu Margin="0,4,0,6" Height="Auto" Grid.Row="2" Grid.Column="0"
+                                      HorizontalAlignment="Center" MinWidth="160" Width="Auto">
+                                    <MenuItem Header="Options" MinWidth="160" Height="Auto" Width="Auto">
+                                        <MenuItem Header="Add New Command Slot"
+                                                  Command="{Binding AddCommandComboBoxRelay}" />
+                                        <MenuItem Header="Add New Parameter Slot"
+                                                  Command="{Binding AddCommandParameterComboBoxRelay}" />
+                                        <MenuItem Header="Remove Parameter Slot"
+                                                  Command="{Binding RemoveCommandParameterComboBoxRelay}" />
+                                        <MenuItem Header="Save Query" Command="{Binding SaveQueryRelay}" />
+                                        <MenuItem Header="Execute" Command="{Binding ExecuteQueryFromQueryBuilderRelay}" />
+                                        <MenuItem Header="Execute to CSV" Command="{Binding OutputToCsvFileRelay}" />
+                                        <MenuItem Header="Execute to Text" Command="{Binding OutputToTextFileRelay}" />
+                                        <MenuItem Header="Export Console Output"
+                                                  Command="{Binding ExportConsoleOutputRelay}" />
+                                        <MenuItem Header="Clear Console Output"
+                                                  Command="{Binding ClearConsoleOutputInQueryBuilderRelay}" />
+                                        <MenuItem Header="Clear Query" Command="{Binding ClearQueryBuilderRelay}" />
                                     </MenuItem>
-                                    <MenuItem Header="Export Console Output"
-                                              Command="{Binding ExportConsoleOutput}"
-                                              />
-                                    <MenuItem Header="Clear Console Output"
-                                              Command="{Binding ClearConsoleOutput}"
-                                              />
-                                    <MenuItem Header="Add Button"
-                                              Command="{Binding AddButton}"
-                                              />
-                                    <MenuItem Header="Clear Query"
-                                              Command="{Binding ClearQueryBuilderRelay}"/>
-
-                                </MenuItem>
-                            </Menu>
-                            <CheckBox x:Name="isEditing" Content="Editing" HorizontalAlignment="Left" Margin="14,57,0,0" VerticalAlignment="Top" IsChecked="{Binding EditingEnabled}"/>
+                                </Menu>
+                                <!-- END of Button ComboBox-->
+                                <CheckBox Grid.Row="2" Grid.Column="0" Content="Editing" HorizontalAlignment="Left"
+                                          Margin="10,6,10,0"
+                                          VerticalAlignment="Top" IsChecked="{Binding QueryEditingEnabled}" Height="15"
+                                          Width="57" />
+                            </Grid>
+                            <!-- ROW 0 END -->
+                            <!-- GRID ROW 1 START -->
+                            <!-- TextBox as Console Output -->
+                            <TextBox Grid.Row="1" Text="{Binding ConsoleOutputInQueryBuilder.ConsoleOutput}"
+                                     HorizontalAlignment="Stretch"
+                                     VerticalAlignment="Stretch" Margin="10" IsReadOnly="True" TextWrapping="Wrap"
+                                     VerticalScrollBarVisibility="Auto" />
+                            <!-- GRID ROW 1 END -->
                         </Grid>
                     </TabItem>
                     <TabItem Header="Active Directory Information">
                         <Grid Background="#FFE5E5E5">
-                            <Button Content="Execute" HorizontalAlignment="Left" Margin="368,43,0,0" VerticalAlignment="Top" Height="23" Width="95"/>
-                            <ComboBox HorizontalAlignment="Left" Margin="31,44,0,0" VerticalAlignment="Top" Width="207" Height="26"/>
-                            <DataGrid d:ItemsSource="{d:SampleData ItemCount=5}" Margin="0,157,0,0"/>
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="Auto" MinHeight="140" />
+                                <RowDefinition MinHeight="100" />
+                            </Grid.RowDefinitions>
+                            <Grid Margin="0,0,0,49" Grid.Row="0">
+                                <!-- TODO: Pieter: Bind button to another property inside the MainWindowViewModel -->
+                                <Button Content="Execute" HorizontalAlignment="Left" Margin="368,43,0,0"
+                                        VerticalAlignment="Top" Height="23" Width="95" />
+                                <ComboBox HorizontalAlignment="Left" Margin="31,44,0,0" VerticalAlignment="Top"
+                                          Width="207" Height="26" 
+                                          SelectedItem="{Binding SelectedCommandFromComboBoxInActiveDirectoryInfo}"
+                                          ItemsSource="{Binding AvailableOptionsFromComboBoxInActiveDirectoryInfo}" />
+                            </Grid>
+                            <!-- TODO: Pieter: Bind this to a property in the MainWindowViewModel -->
+                            <TextBox Grid.Row="1" Text="{Binding ConsoleOutputInActiveDirectoryInfo.ConsoleOutput}"
+                                     HorizontalAlignment="Stretch"
+                                     VerticalAlignment="Stretch" Margin="10" IsReadOnly="True" TextWrapping="Wrap"
+                                     VerticalScrollBarVisibility="Auto" />
                         </Grid>
                     </TabItem>
                 </TabControl>
             </Grid>
         </Grid>
     </Grid>
-</Window>
+</Window>
\ No newline at end of file
diff --git a/ActiveDirectoryQuerier/MainWindow.xaml.cs b/ActiveDirectoryQuerier/MainWindow.xaml.cs
index ed4f897..c7ca4d1 100644
--- a/ActiveDirectoryQuerier/MainWindow.xaml.cs
+++ b/ActiveDirectoryQuerier/MainWindow.xaml.cs
@@ -5,5 +5,6 @@ public partial class MainWindow
     public MainWindow()
     {
         InitializeComponent();
+        DataContext = new MainWindowViewModel();
     }
 }
diff --git a/ActiveDirectoryQuerier/MainWindowViewModel.cs b/ActiveDirectoryQuerier/MainWindowViewModel.cs
index 540bd5c..679b17b 100644
--- a/ActiveDirectoryQuerier/MainWindowViewModel.cs
+++ b/ActiveDirectoryQuerier/MainWindowViewModel.cs
@@ -7,70 +7,70 @@
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
+using ActiveDirectoryQuerier.ActiveDirectory;
 using ActiveDirectoryQuerier.PowerShell;
+using ActiveDirectoryQuerier.Queries;
+using ActiveDirectoryQuerier.ViewModels;
 using Microsoft.Win32;
-using static ActiveDirectoryQuerier.PowerShell.CustomQueries;
 
 namespace ActiveDirectoryQuerier;
 
-/// <summary>
-/// Primary view model for the MainWindow.
-/// </summary>
 public sealed class MainWindowViewModel : INotifyPropertyChanged
 {
-    // [ Fields ]-------------------------------------------------------------------- //
+    // [ Fields ] ------------------------------------------------------------------- //
     // [[ Event handler property ]] ------------------------------------------------- //
 
     public event PropertyChangedEventHandler? PropertyChanged;
 
     // [[ Backing fields for properties ]] ------------------------------------------ //
 
-    private string _powerShellOutput;
+    private bool _queryEditingEnabled;
     private string _queryName;
     private string _queryDescription;
-    private bool _EditingEnabled;
-    private Command? _selectedComboBoxCommand;
-    private ObservableCollection<Button>? _buttons;
+    private AppConsole _consoleOutputInQueryBuilder;
+    private AppConsole _consoleOutputInActiveDirectoryInfo;
+    private Command? _selectedCommandFromComboBoxInQueryBuilder;
+    private Command? _selectedCommandFromComboBoxInActiveDirectoryInfo;
+    private ObservableCollection<Button>? _buttons; // TODO: Rename to be more descriptive.
 
     // [[ Other fields ]] ----------------------------------------------------------- //
 
-    private readonly CustomQueries _customQuery;
     private readonly Query _currentQuery;
-    // Probably want to add the ability to toggle editing vs not editing but filled in.
+    private readonly CustomQueries _customQuery;
+    private readonly PSExecutor _psExecutor;
     private Query? _isEditing;
-    private readonly PowerShellExecutor _powerShellExecutor;
 
     // [ Properties ] --------------------------------------------------------------- //
     // [[ Properties for backing fields ]] ------------------------------------------ //
 
-    /// <summary>
-    /// This is tied to the Editing checkbox and will allow the user to edit the custom queries or not to
-    /// </summary>
-    public bool EditingEnabled
+    public bool QueryEditingEnabled
     {
-        get { return _EditingEnabled; }
-        set
-        {
-            _EditingEnabled = value;
-            OnPropertyChanged("EditingEnabled");
+        get => _queryEditingEnabled;
+        set {
+            _queryEditingEnabled = value;
+            OnPropertyChanged(nameof(QueryEditingEnabled));
         }
     }
 
-    /// <summary>
-    /// Gets or sets the output of the executed PowerShell command.
-    /// </summary>
-    public string PowerShellOutput
+    public AppConsole ConsoleOutputInQueryBuilder
     {
-        get => _powerShellOutput;
+        get => _consoleOutputInQueryBuilder;
         set {
-            _powerShellOutput = value;
-            OnPropertyChanged(nameof(PowerShellOutput));
+            _consoleOutputInQueryBuilder = value;
+            OnPropertyChanged(nameof(ConsoleOutputInQueryBuilder));
+        }
+    }
+
+    // TODO: Pieter: Use this for the console output in the Active Directory Info tab (link in GUI)
+    public AppConsole ConsoleOutputInActiveDirectoryInfo
+    {
+        get => _consoleOutputInActiveDirectoryInfo;
+        set {
+            _consoleOutputInActiveDirectoryInfo = value;
+            OnPropertyChanged(nameof(ConsoleOutputInActiveDirectoryInfo));
         }
     }
 
-    /// <summary>
-    /// The name of the query.
-    /// </summary>
     public string QueryName
     {
         get => _queryName;
@@ -83,9 +83,6 @@ public string QueryName
         }
     }
 
-    /// <summary>
-    /// The description of the query.
-    /// </summary>
     public string QueryDescription
     {
         get => _queryDescription;
@@ -98,319 +95,339 @@ public string QueryDescription
         }
     }
 
-    /// <summary>
-    /// Gets or sets the currently selected PowerShell command.
-    /// </summary>
-    public Command? SelectedComboBoxCommand
+    public Command? SelectedCommandFromComboBoxInQueryBuilder
     {
-        get => _selectedComboBoxCommand;
+        get => _selectedCommandFromComboBoxInQueryBuilder;
         set {
-            _selectedComboBoxCommand = value;
-            OnPropertyChanged(nameof(SelectedComboBoxCommand));
-            LoadCommandParametersAsync(value);
+            _selectedCommandFromComboBoxInQueryBuilder = value;
+            OnPropertyChanged(nameof(SelectedCommandFromComboBoxInQueryBuilder));
+            // No need to load parameters if the command is null.
+            if (value is not null)
+            {
+                // TODO: Figure out how to resolve the warning about the async method not being awaited!!!
+                LoadCommandParametersAsync(value);
+            }
         }
     }
 
-    /// <summary>
-    /// This property creates a collection of buttons to be added to the stack panel for custom queries
-    /// </summary>
+    public Command? SelectedCommandFromComboBoxInActiveDirectoryInfo
+    {
+        get => _selectedCommandFromComboBoxInActiveDirectoryInfo;
+        set {
+            if (_selectedCommandFromComboBoxInActiveDirectoryInfo != value)
+            {
+                _selectedCommandFromComboBoxInActiveDirectoryInfo = value;
+                OnPropertyChanged(nameof(SelectedCommandFromComboBoxInActiveDirectoryInfo));
+            }
+        }
+    }
+
+    public List<string> AvailableOptionsFromComboBoxInActiveDirectoryInfo {
+        get;
+    } = new() { "Get user on domain", "Get computers on domain", "Get IP of each system on domain" };
+
     public ObservableCollection<Button> QueryButtonStackPanel => _buttons ??= new ObservableCollection<Button>();
 
     // [[ Other properties ]] ------------------------------------------------------- //
 
-    /// <summary>
-    /// Collection of Active Directory commands available for execution.
-    /// </summary>
-    public ObservableCollection<Command> ActiveDirectoryCommandsList { get; private set; }
+    // ReSharper disable once InconsistentNaming
+    public ObservableCollection<Command> ADCommands { get; private set; }
+    // ReSharper disable once InconsistentNaming
+    public ObservableCollection<string>? AvailableADCommandParameters { get; private set; }
+    // ReSharper disable once InconsistentNaming
+    public ObservableCollection<ComboBoxParameterViewModel> DynamicallyAvailableADCommandParametersComboBox { get; }
+    // ReSharper disable once InconsistentNaming
+    public ObservableCollection<TextBoxViewModel> DynamicallyAvailableADCommandParameterValueTextBox { get; }
 
-    /// <summary>
-    /// Collection of possible parameters for the currently selected command.
-    /// </summary>
-    public ObservableCollection<string>? PossibleCommandParametersList { get; private set; }
-
-    /// <summary>
-    /// Collection of ComboBoxParameterViewModels to dynamically handle multiple parameter selections.
-    /// </summary>
-    public ObservableCollection<ComboBoxParameterViewModel> DynamicParametersCollection { get; }
+    // [[ GUI element relays ]] ----------------------------------------------------- //
+    // [[[ Dynamically created elements ]]] ----------------------------------------- //
 
-    /// <summary>
-    /// Collection of ComboBoxParameterViewModels to dynamically handle multiple parameter value selections.
-    /// </summary>
-    public ObservableCollection<TextBoxViewModel> DynamicParameterValuesCollection { get; }
+    private ICommand EditQueryFromQueryStackPanelRelay { get; }
+    private ICommand DeleteQueryFromQueryStackPanelRelay { get; }
+    private ICommand ExecuteQueryFromQueryStackPanelRelay { get; }
 
-    /// <summary>
-    /// This is a helper command for running SaveCustomQueries
-    /// </summary>
-    public ICommand SaveCustomQueriesRelay { get; }
+    // [[[ Existing GUI elements ]]] ------------------------------------------------ //
 
-    /// <summary>
-    /// This is the command tied to Clear Query calls the ClearQueryBuilder method 
-    /// </summary>
+    public ICommand SaveQueryRelay { get; }
     public ICommand ClearQueryBuilderRelay { get; }
-
-    /// <summary>
-    /// This is the command for the edit option on custom queries
-    /// TODO: Change property name to be a non-verb.
-    /// </summary>
-    private ICommand EditCustomQueryRelay { get; }
-
-    /// <summary>
-    /// This is tied to the Button menu calls the DeleteCustomQuery method to delete a CustomQuery button
-    /// </summary>
-    private ICommand DeleteCustomQueryRelay { get; }
-
-    /// <summary>
-    /// Command to execute the selected PowerShell command.
-    /// TODO: Change property name???
-    /// </summary>
-    public ICommand ExecuteCommandRelay { get; }
-
-    /// <summary>
-    /// Command to execute the buttons inside Custom Command buttons
-    /// TODO: Change property name???
-    /// </summary>
-    private ICommand ExecuteCommandButtonRelay { get; }
-
-    /// <summary>
-    /// Command to add a new parameter ComboBox to the UI.
-    /// </summary>
-    public ICommand AddParameterComboBoxRelay { get; }
-
-    /// <summary>
-    /// Command to add a new command ComboBox to the UI.
-    /// </summary>
+    public ICommand ExecuteQueryFromQueryBuilderRelay { get; }
+    public ICommand ExecuteQueryFromActiveDirectoryInfoRelay { get; } // TODO: Pieter use this for execution button
     public ICommand AddCommandComboBoxRelay { get; }
-
-    /// <summary>
-    /// Command to add a new parameter ComboBox to the UI.
-    /// TODO: Rename this property to match Property naming conventions!!!
-    /// </summary>
-    public ICommand RemoveParameterComboBoxRelay { get; }
-
-    /// <summary>
-    /// Command to have the output send to a text file when executing
-    /// TODO: Get-only auto-property 'OutputToTextFileAsync' is never assigned!!!
-    /// </summary>
+    public ICommand AddCommandParameterComboBoxRelay { get; }
+    public ICommand RemoveCommandParameterComboBoxRelay { get; }
     public ICommand OutputToTextFileRelay { get; }
-
-    /// <summary>
-    /// Command to output to a csv when executing
-    /// </summary>
     public ICommand OutputToCsvFileRelay { get; }
+    public ICommand ExportConsoleOutputRelay { get; }
+    public ICommand ClearConsoleOutputInQueryBuilderRelay { get; }
+    public ICommand ImportQueryFileRelay { get; }
+    public ICommand CreateNewQueryFileRelay { get; }
+    public ICommand ClearConsoleOutputInActiveDirectoryInfoRelay { get; } // TODO: Impliment functionality.....
+
+    /* TODO: for Pieter
+     *
+     * Create a property that contains the ComboBox dropdown options/text.
+     *
+     * Create a property that will contain the selected item.
+     *
+     * Create a property to act as the relay to the execution button.
+     */
+
+    // NEW CODE
+    //  [ Constructor ] ------------------------------------------------------------- //
 
-    // [ Constructors ] ------------------------------------------------------------ //
-
-    /// <summary>
-    /// Class constructor.
-    /// TODO: Fix warnings about possible null values.
-    /// </summary>
     public MainWindowViewModel()
     {
-        // TODO: Possibly make the fields nullable to enforce they are filled when saved and such.
-        _powerShellOutput = string.Empty;
-        // TODO: Possibly make the fields nullable to enforce they are filled when saved and such.
         _queryName = string.Empty;
-        // TODO: Possibly make the fields nullable to enforce they are filled when saved and such.
         _queryDescription = string.Empty;
-        _powerShellExecutor = new PowerShellExecutor();
+        _consoleOutputInQueryBuilder = new AppConsole();
+        _consoleOutputInActiveDirectoryInfo = new AppConsole();
+        _psExecutor = new PSExecutor();
         _customQuery = new CustomQueries();
         _currentQuery = new Query();
 
-        ActiveDirectoryCommandsList = new ObservableCollection<Command>();
-        DynamicParametersCollection = new ObservableCollection<ComboBoxParameterViewModel>();
-        DynamicParameterValuesCollection = new ObservableCollection<TextBoxViewModel>();
-
-        ExecuteCommandRelay = new RelayCommand(ExecuteCommandAsync);
-        OutputToCsvFileRelay = new RelayCommand(OutputToCsvFileAsync);
-        OutputToTextFileRelay = new RelayCommand(OutputToTextFileAsync);
-        AddParameterComboBoxRelay = new RelayCommand(AddParameterComboBox);
-        AddCommandComboBoxRelay = new RelayCommand(AddCommandComboBox);
-        RemoveParameterComboBoxRelay = new RelayCommand(RemoveParameterComboBox);
-        SaveCustomQueriesRelay = new RelayCommand(SaveCustomQueries);
-        EditCustomQueryRelay = new RelayCommand(EditCustomQuery);
-        DeleteCustomQueryRelay = new RelayCommand(DeleteCustomQuery);
-        ExecuteCommandButtonRelay = new RelayCommand(ExecuteCustomQueryCommandButton);
+        ADCommands = new ObservableCollection<Command>();
+        DynamicallyAvailableADCommandParametersComboBox = new ObservableCollection<ComboBoxParameterViewModel>();
+        DynamicallyAvailableADCommandParameterValueTextBox = new ObservableCollection<TextBoxViewModel>();
+
+        OutputToCsvFileRelay = new RelayCommand(OutputExecutionResultsToCsvFileAsync);
+        OutputToTextFileRelay = new RelayCommand(OutputExecutionResultsToTextFileAsync);
+        ExportConsoleOutputRelay = new RelayCommand(ExportConsoleOutputToFile);
+        // TODO: Figure out how resolve the warning about the async method not being awaited.
+        ExecuteQueryFromQueryBuilderRelay = new RelayCommand(
+            _ => ExecuteQuery(_consoleOutputInQueryBuilder));
+        // TODO: Figure out how resolve the warning about the async method not being awaited.
+        ExecuteQueryFromActiveDirectoryInfoRelay = new RelayCommand(
+            _ => ExecuteQuery(_consoleOutputInActiveDirectoryInfo));
+        ImportQueryFileRelay = new RelayCommand(ImportQueryFile);
+        CreateNewQueryFileRelay = new RelayCommand(CreateNewQueryFile);
+        AddCommandParameterComboBoxRelay = new RelayCommand(AddParameterComboBoxInQueryBuilder);
+        AddCommandComboBoxRelay = new RelayCommand(AddCommandComboBoxInQueryBuilder);
+        RemoveCommandParameterComboBoxRelay = new RelayCommand(RemoveCommandParameterComboBoxInQueryBuilder);
+        SaveQueryRelay = new RelayCommand(SaveQuery);
+        EditQueryFromQueryStackPanelRelay = new RelayCommand(EditQueryFromQueryStackPanel);
+        DeleteQueryFromQueryStackPanelRelay = new RelayCommand(DeleteQueryFromQueryStackPanel);
+        ExecuteQueryFromQueryStackPanelRelay = new RelayCommand(ExecuteQueryFromQueryStackPanel);
+        ClearConsoleOutputInQueryBuilderRelay = new RelayCommand(
+            _ => ClearConsoleOutput(_consoleOutputInQueryBuilder));
+        ClearConsoleOutputInActiveDirectoryInfoRelay = new RelayCommand(
+            _ => ClearConsoleOutput(_consoleOutputInActiveDirectoryInfo));
         ClearQueryBuilderRelay = new RelayCommand(ClearQueryBuilder);
 
-        InitializeActiveDirectoryCommandsAsync();
-        LoadCustomQueries(); // Calls method to deserialize and load buttons.
+        /* TODO: For Pieter
+         * Connect the relay property to for the execute button to you method that performs the execution.
+         */
 
-        // Debug
-        /*
-        foreach (Button t in QueryButtonStackPanel)
-        {
-            CustomQueries.Query test = (CustomQueries.Query)t.Tag;
-            Trace.WriteLine(test.CommandName);
-        }
-        */
+        // TODO: Figure out how resolve the warning about the async method not being awaited.
+        InitializeActiveDirectoryCommandsAsync();
+        LoadSavedQueriesFromFile(); // Calls method to deserialize and load buttons.
     }
 
     // [ Methods ] ----------------------------------------------------------------- //
 
-    /// <summary>
-    /// This method will edit the Query and fill out the field with the desired query and you can edit the query
-    /// </summary>
-    /// <note>
-    /// This method is of scope internal because it is tested in the test project, but should remain private.
-    /// </note>
-    /// <param name="sender">This is the object that is clicked when executing</param>
-    private void EditCustomQuery(object sender)
+    /* TODO: Info for Pieter to get started
+     * Create a class (outside of this one) that will contain three methods, all of each will perform one specific
+     * action, such as getting the users on the domain, getting computers on the domain, and getting the IP of each
+     * system on the domain.
+     *      - The methods in this class should use the powershell executor to execute the specific command.
+     *      - Make method async, and utilize the async execute methods in the powershell executor.
+     *
+     *      public async Task<the return type> MethodName() { } // don't forget to use await when dealing with async
+     *                                                             methods.
+     *
+     * In this class, create a method or two, that will be used to execute the specific selected action.
+     */
+
+    private void ClearConsoleOutput(AppConsole appConsole)
     {
-        // Get the button that we are editing
-        Button currButton = (Button)sender;
-        Query currQuery = (Query)currButton.Tag;
+        if (appConsole.ConsoleOutput.Length == 0)
+        {
+            MessageBox.Show("The console is already clear.",
+                            "Information",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Information);
+            return;
+        }
 
-        _isEditing = currQuery;
-        EditingEnabled = true;
+        MessageBoxResult result = MessageBox.Show("Are you sure you want to clear the console output?",
+                                                  "Warning",
+                                                  MessageBoxButton.YesNo,
+                                                  MessageBoxImage.Warning,
+                                                  MessageBoxResult.No);
 
-        // Need to fill in the queryName
-        QueryName = currQuery.QueryName;
+        if (result == MessageBoxResult.Yes)
+        {
+            appConsole.Clear();
+        }
+    }
+
+    private void EditQueryFromQueryStackPanel(object queryButton)
+    {
+        var currentQuery = (Query)((Button)queryButton).Tag;
 
-        // Fill in the queryDescription
-        QueryDescription = currQuery.QueryDescription;
+        _isEditing = currentQuery;
+        QueryEditingEnabled = true;
+        QueryName = currentQuery.QueryName;
+        QueryDescription = currentQuery.QueryDescription;
 
         // Fill in the commandName
-        Command chosenCommand =
-            ActiveDirectoryCommandsList.FirstOrDefault(item => item.CommandText == currQuery.CommandName)!;
-        SelectedComboBoxCommand = chosenCommand;
+        Command chosenCommand = ADCommands.FirstOrDefault(item => item.CommandText == currentQuery.PSCommandName)!;
+        SelectedCommandFromComboBoxInQueryBuilder = chosenCommand;
 
         // Load the Possible Parameters Synchronously
-        CommandParameters commandParameters = new CommandParameters();
-        ((ICommandParameters)commandParameters).LoadCommandParameters(SelectedComboBoxCommand);
-        PossibleCommandParametersList = new ObservableCollection<string>(commandParameters.PossibleParameters);
-        OnPropertyChanged(nameof(PossibleCommandParametersList));
+        ADCommandParameters adCommandParameters = new();
+        adCommandParameters.LoadAvailableParameters(SelectedCommandFromComboBoxInQueryBuilder);
+        AvailableADCommandParameters = new ObservableCollection<string>(adCommandParameters.AvailableParameters);
+        OnPropertyChanged(nameof(AvailableADCommandParameters));
 
-        // Check to see if the DynamicParametersCollection is empty and clear it if it is
-        if (DynamicParametersCollection.Count != 0)
+        // Check to see if the DynamicallyAvailableADCommandParametersComboBox is empty and clear it if it is
+        if (DynamicallyAvailableADCommandParametersComboBox.Count != 0)
         {
-            DynamicParametersCollection.Clear();
-            DynamicParameterValuesCollection.Clear();
+            DynamicallyAvailableADCommandParametersComboBox.Clear();
+            DynamicallyAvailableADCommandParameterValueTextBox.Clear();
         }
 
         // Fill in Parameters and values
-        for (int i = 0; i < currQuery.CommandParameters.Length; i++)
+        for (var i = 0; i < currentQuery.PSCommandParameters.Length; i++)
         {
-            Trace.WriteLine(currQuery.CommandParameters[i]);
+            Trace.WriteLine(currentQuery.PSCommandParameters[i]);
 
             // Adds the Parameters boxes
-            object temp = new();
-            AddParameterComboBox(temp);
+            AddParameterComboBoxInQueryBuilder(null!); // Null is never used, so we use null forgiveness operator.
 
             // Fill in the parameter boxes
-            DynamicParametersCollection[i].SelectedParameter = currQuery.CommandParameters[i];
-            DynamicParameterValuesCollection[i].SelectedParameterValue = currQuery.CommandParametersValues[i];
+            DynamicallyAvailableADCommandParametersComboBox[i].SelectedParameter = currentQuery.PSCommandParameters[i];
+            DynamicallyAvailableADCommandParameterValueTextBox[i].SelectedParameterValue =
+                currentQuery.PSCommandParameterValues[i];
         }
     }
 
-    /// <summary>
-    /// This method executes the CustomQuery.query.command that is tied to the custom query buttons
-    /// </summary>
-    /// <param name="_">This is the Button as a generic object that is clicked when executing</param>
-    private async void ExecuteCustomQueryCommandButton(object _)
+    private async void ExecuteQueryFromQueryStackPanel(object queryButton)
     {
-        var currentButton = _ as Button;
-
-        if (currentButton is null)
+        if (queryButton is not Button currentButton)
         {
+            Trace.WriteLine("No button selected.");
+            MessageBox.Show("To execute a query, you must first select a query.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
             return;
         }
 
-        Query buttonQuery = (Query)currentButton.Tag;
-        await ExecuteGenericCommand(buttonQuery.Command);
+        var buttonQuery = (Query)currentButton.Tag;
+        await ExecuteQueryCoreAsync(ConsoleOutputInQueryBuilder, buttonQuery.Command);
     }
 
-    /// <summary>
-    /// This method deletes the button from the list and saves the changes to the file
-    /// </summary>
-    /// <param name="_">This is the Button as a generic object that is clicked when executing</param>
-    private void DeleteCustomQuery(object _)
+    private void DeleteQueryFromQueryStackPanel(object queryButton)
     {
-        // Delete a button from the custom queries list and from the file
-        var currentButton = _ as Button;
-
-        if (currentButton is null)
+        if (queryButton is not Button currentButton)
         {
+            Trace.WriteLine("No button selected.");
+            MessageBox.Show("To delete a query, you must first select a query.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
             return;
         }
 
-        QueryButtonStackPanel.Remove(currentButton);
-        _customQuery.Queries.Remove((Query)currentButton.Tag);
-        _customQuery.SerializeMethod();
+        MessageBoxResult result = MessageBox.Show("Are you sure you want to delete the query?",
+                                                  "Warning",
+                                                  MessageBoxButton.YesNo,
+                                                  MessageBoxImage.Warning,
+                                                  MessageBoxResult.No);
+
+        if (result == MessageBoxResult.Yes)
+        {
+            QueryButtonStackPanel.Remove(currentButton);
+            _customQuery.Queries.Remove((Query)currentButton.Tag);
+            _customQuery.SaveQueriesToJson();
+        }
+    }
+
+    private void CreateNewQueryFile(object _)
+    {
+        // Saves/creates a new save file for the queries
+        SaveFileDialog saveFileDialog = new SaveFileDialog();
+        saveFileDialog.Filter = "Json files (*.json)|*.json|Text files (*.txt)|*.txt";
+        if (saveFileDialog.ShowDialog() == true)
+        {
+            File.WriteAllText(saveFileDialog.FileName, string.Empty);
+            _customQuery.CustomQueryFileLocation = saveFileDialog.FileName;
+        }
     }
 
-    /// <summary>
-    /// This method will load the custom queries from the file.
-    /// TODO: Remove any unused variables.
-    /// </summary>
-    private void LoadCustomQueries()
+    private void LoadSavedQueriesFromFile()
     {
         try
         {
             // Load the custom queries from the file (Deserialize)
             _customQuery.LoadData();
 
-            // Loop through the queries and create a button for each one
-            int i = 0;
-            foreach (Query cQuery in _customQuery.Queries)
+            // Loop through the queries and create a button for each one.
+            foreach (var newButton in _customQuery.Queries.Select(CreateQueryButtonInStackPanel))
             {
-                // Creates a new button for each query
-                Button newButton = CreateCustomButton(cQuery);
-
                 // Lastly add the button to the stack panel
                 QueryButtonStackPanel.Add(newButton);
-                i++;
             }
         }
+        // TODO: Possibly provide more comprehensive error handling.
         catch (Exception ex)
         {
             Trace.WriteLine(ex);
         }
     }
 
-    /// <summary>
-    /// Executes the selected PowerShell command asynchronously.
-    /// </summary>
-    /// <param name="_">Parameter is not used, but required for the ICommand interface.</param>
-    private async void ExecuteCommandAsync(object _)
+    private void ImportQueryFile(object _)
     {
-        await ExecuteSelectedCommandAsync();
+        OpenFileDialog dialog =
+            new() { FileName = "CustomQueries.dat", Filter = "Json files (*.json)|*.json|Text Files (*.txt)|*.txt" };
+
+        // Display
+        bool? result = dialog.ShowDialog();
+
+        // Get file and write text
+        if (result == true)
+        {
+            // Open document
+            _customQuery.CustomQueryFileLocation = dialog.FileName;
+
+            QueryButtonStackPanel.Clear();
+            LoadSavedQueriesFromFile();
+        }
     }
 
-    /// <summary>
-    /// Initializes the list of Active Directory commands asynchronously.
-    /// </summary>
+    // TODO: Possibly change Task to void?
+    private async Task ExecuteQuery(AppConsole appConsole, Command? command = null)
+    {
+        await ExecuteQueryCoreAsync(appConsole, command);
+    }
+
+    // TODO: Possibly change Task to void?
     private async Task InitializeActiveDirectoryCommandsAsync()
     {
-        ObservableCollection<Command> list = await ActiveDirectoryCommands.GetActiveDirectoryCommands();
-        ActiveDirectoryCommandsList = new(list);
-        OnPropertyChanged(nameof(ActiveDirectoryCommandsList));
+        ObservableCollection<Command> list = await ADCommandsFetcher.GetADCommands();
+        ADCommands = new ObservableCollection<Command>(list);
+        OnPropertyChanged(nameof(ADCommands));
     }
 
-    /// <summary>
-    /// Loads the parameters for the selected PowerShell command asynchronously.
-    /// </summary>
-    /// <param name="selectedCommand">The PowerShell command whose parameters are to be loaded.</param>
     private async Task LoadCommandParametersAsync(Command? selectedCommand)
     {
-        CommandParameters commandParameters = new();
-        await commandParameters.LoadCommandParametersAsync(selectedCommand);
-        PossibleCommandParametersList = new ObservableCollection<string>(commandParameters.PossibleParameters);
-        OnPropertyChanged(nameof(PossibleCommandParametersList));
+        ADCommandParameters adCommandParameters = new();
+        await adCommandParameters.LoadAvailableParametersAsync(selectedCommand);
+        AvailableADCommandParameters = new ObservableCollection<string>(adCommandParameters.AvailableParameters);
+        OnPropertyChanged(nameof(AvailableADCommandParameters));
 
         // Update the possible properties of the ComboBoxParameterViewModels.
-        foreach (ComboBoxParameterViewModel comboBoxParameterViewModel in DynamicParametersCollection)
+        foreach (ComboBoxParameterViewModel comboBoxParameterViewModel in
+                     DynamicallyAvailableADCommandParametersComboBox)
         {
-            comboBoxParameterViewModel.PossibleParameterList = PossibleCommandParametersList;
+            comboBoxParameterViewModel.AvailableParameters = AvailableADCommandParameters;
         }
     }
 
-    /// <summary>
-    /// Executes the currently selected PowerShell command and updates the PowerShellOutput property with the result.
-    /// </summary>
-    /// <returns>A Task representing the asynchronous operation of executing the command.</returns>
-    private async Task ExecuteSelectedCommandAsync()
+    // TODO: Hunter: Re-review this method and make any necessary changes.
+    private async Task ExecuteQueryCoreAsync(AppConsole appConsole, Command? command = null)
     {
-        if (SelectedComboBoxCommand is null)
+        if (SelectedCommandFromComboBoxInQueryBuilder is null && command is null)
         {
             Trace.WriteLine("No command selected.");
             MessageBox.Show("To execute a command, you must first select a command.",
@@ -422,68 +439,38 @@ private async Task ExecuteSelectedCommandAsync()
 
         try
         {
-            // Add selected parameters and their values to the command.
-            for (int i = 0; i < DynamicParametersCollection.Count; i++)
+            PSOutput result;
+            if (command is not null)
             {
-                string parameterName = DynamicParametersCollection[i].SelectedParameter;
-                string parameterValue = DynamicParameterValuesCollection[i].SelectedParameterValue;
-                SelectedComboBoxCommand.Parameters.Add(new CommandParameter(parameterName, parameterValue));
+                result = await _psExecutor.ExecuteAsync(command);
             }
-
-            ReturnValues result = await _powerShellExecutor.ExecuteAsync(SelectedComboBoxCommand);
-
-            if (result.HadErrors)
+            else
             {
-                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
-                return;
+                // Add selected parameters and their values to the command.
+                UpdateSelectedCommand();
+                result = await _psExecutor.ExecuteAsync(SelectedCommandFromComboBoxInQueryBuilder);
             }
 
-            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
-        }
-        catch (Exception ex)
-        {
-            PowerShellOutput = $"Error executing command: {ex.Message}";
-        }
-    }
-
-    /// <summary>
-    /// Executes the inputted Command PowerShell command and updates the PowerShellOutput property with the result.
-    /// TODO: Rename this method...
-    /// TODO: Does this method do the same thing an another method???
-    /// </summary>
-    /// <param name="toBeExecuted">This is the command to be executed</param>
-    /// <returns>A Task representing the asynchronous operation of executing the command.</returns>
-    private async Task ExecuteGenericCommand(Command? toBeExecuted)
-    {
-        try
-        {
-            // Execute the command
-            ReturnValues result = await _powerShellExecutor.ExecuteAsync(toBeExecuted);
-            // Error handling
             if (result.HadErrors)
             {
-                PowerShellOutput = string.Join(Environment.NewLine, result.StdErr);
+                appConsole.Append(result.StdErr);
                 return;
             }
 
-            PowerShellOutput = string.Join(Environment.NewLine, result.StdOut);
+            appConsole.Append(result.StdOut);
         }
         catch (Exception ex)
         {
-            PowerShellOutput = $"Error executing command: {ex.Message}";
+            appConsole.Append($"Error executing command: {ex.Message}" + ex.Message);
         }
     }
 
-    /// <summary>
-    /// Adds a new parameter and value selection ComboBox to the DynamicParametersCollection.
-    /// </summary>
-    /// <param name="_">This is the object that the command is bound to</param>
-    private void AddParameterComboBox(object _)
+    private void AddParameterComboBoxInQueryBuilder(object _)
     {
         // Check if some variable is null and throw an exception if it is
-        if (PossibleCommandParametersList is null)
+        if (AvailableADCommandParameters is null)
         {
-            Trace.WriteLine("PossibleCommandParametersList has not been populated yet.");
+            Trace.WriteLine("AvailableADCommandParameters has not been populated yet.");
             MessageBox.Show("To add a parameter, you must first select a command.",
                             "Warning",
                             MessageBoxButton.OK,
@@ -491,32 +478,23 @@ private void AddParameterComboBox(object _)
             return;
         }
 
-        DynamicParametersCollection.Add(new ComboBoxParameterViewModel(PossibleCommandParametersList));
-        DynamicParameterValuesCollection.Add(new TextBoxViewModel());
+        DynamicallyAvailableADCommandParametersComboBox.Add(
+            new ComboBoxParameterViewModel(AvailableADCommandParameters));
+        DynamicallyAvailableADCommandParameterValueTextBox.Add(new TextBoxViewModel());
     }
 
-    /// <summary>
-    /// TODO: Add a summary.
-    /// </summary>
-    /// <param name="_">This is the object that the command is bound to.</param>
-    private void AddCommandComboBox(object _)
+    private void AddCommandComboBoxInQueryBuilder(object _)
     {
-        // throw new NotImplementedException();
         Trace.WriteLine("Not implemented yet.");
         MessageBox.Show("Not implemented yet.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
     }
 
-    /// <summary>
-    /// This method executes the currently selected command and saves the output to a text file.
-    /// </summary>
-    /// <param name="_">Represents the object that the command is bound to.</param>
-    private async void OutputToTextFileAsync(object _)
+    private async void OutputExecutionResultsToTextFileAsync(object _)
     {
-        await ExecuteSelectedCommandAsync();
+        await ExecuteQueryCoreAsync(ConsoleOutputInQueryBuilder);
 
         // Filepath
         // Write the text to a file & prompt user for the location
-
         SaveFileDialog saveFileDialog = new() {                       // Set properties of the OpenFileDialog
                                                FileName = "Document", // Default file name
                                                Filter = "All files(*.*) | *.*"
@@ -530,7 +508,7 @@ private async void OutputToTextFileAsync(object _)
         {
             // Open document
             string filePath = saveFileDialog.FileName;
-            await File.WriteAllTextAsync(filePath, PowerShellOutput);
+            await File.WriteAllTextAsync(filePath, ConsoleOutputInQueryBuilder.ConsoleOutput);
         }
     }
 
@@ -539,12 +517,12 @@ private async void OutputToTextFileAsync(object _)
     /// Status: prompts user for file path and saves correctly though the string could be edited to be better
     /// </summary>
     /// <param name="_">Represents the object that the command is bound to</param>
-    private async void OutputToCsvFileAsync(object _)
+    private async void OutputExecutionResultsToCsvFileAsync(object _)
     {
-        await ExecuteSelectedCommandAsync();
+        await ExecuteQueryCoreAsync(ConsoleOutputInQueryBuilder);
 
         var csv = new StringBuilder();
-        string[] output = PowerShellOutput.Split(' ', '\n');
+        string[] output = ConsoleOutputInQueryBuilder.ConsoleOutput.Split(' ', '\n');
 
         for (int i = 0; i < output.Length - 2; i++)
         {
@@ -570,14 +548,35 @@ private async void OutputToCsvFileAsync(object _)
         }
     }
 
+    private void ExportConsoleOutputToFile(object _)
+    {
+        if (ConsoleOutputInQueryBuilder.ConsoleOutput.Length == 0)
+        {
+            MessageBox.Show("The console is empty.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
+            return;
+        }
+
+        SaveFileDialog saveFileDialog = new() { DefaultExt = ".txt", Filter = "Text documents (.txt)|*.txt" };
+
+        bool? result = saveFileDialog.ShowDialog();
+
+        if (result == true)
+        {
+            string filename = saveFileDialog.FileName;
+            ConsoleOutputInQueryBuilder.ExportToText(filename);
+        }
+    }
+
     /// <summary>
     /// This method is for getting the currently selected command at anytime
-    /// TODO: !Still in the works!
-    /// TODO: Does this method do the same thing an another method???
     /// </summary>
+    /// <note>
+    /// TODO: !Still in the works!
+    /// TODO: Does this method do the same thing an another method?
+    /// </note>
     private void UpdateSelectedCommand()
     {
-        if (SelectedComboBoxCommand is null)
+        if (SelectedCommandFromComboBoxInQueryBuilder is null)
         {
             Trace.WriteLine("No command selected.");
             MessageBox.Show("To save a query, you must first select a command.",
@@ -590,11 +589,12 @@ private void UpdateSelectedCommand()
         // Try to get the content within the drop downs
         try
         {
-            for (int i = 0; i < DynamicParametersCollection.Count; i++)
+            SelectedCommandFromComboBoxInQueryBuilder.Parameters.Clear();
+            for (int i = 0; i < DynamicallyAvailableADCommandParametersComboBox.Count; i++)
             {
-                SelectedComboBoxCommand.Parameters.Add(
-                    new CommandParameter(DynamicParametersCollection[i].SelectedParameter,
-                                         DynamicParameterValuesCollection[i].SelectedParameterValue));
+                SelectedCommandFromComboBoxInQueryBuilder.Parameters.Add(
+                    new CommandParameter(DynamicallyAvailableADCommandParametersComboBox[i].SelectedParameter,
+                                         DynamicallyAvailableADCommandParameterValueTextBox[i].SelectedParameterValue));
             }
         }
         catch (Exception ex)
@@ -605,62 +605,68 @@ private void UpdateSelectedCommand()
 
     /// <summary>
     /// Updates the _currentQuery object with the current query information.
+    /// </summary>
+    /// <note>
     /// TODO: It needs to be tested! Still in the works!
     /// TODO: Fix any and all warnings about possible null values.
-    /// </summary>
+    /// </note>
     private void GetCurrentQuery()
     {
-        // Update the selected command
         UpdateSelectedCommand();
 
         try
         {
-            string[] commandParameters = new string[SelectedComboBoxCommand.Parameters.Count];
-            string[] commandParameterValues = new string[SelectedComboBoxCommand.Parameters.Count];
+            string[] commandParameters;
+            string[] commandParameterValues;
 
-            _currentQuery.QueryDescription = QueryDescription;
-            _currentQuery.QueryName = QueryName;
+            if (SelectedCommandFromComboBoxInQueryBuilder?.Parameters != null)
+            {
+                commandParameters = new string[SelectedCommandFromComboBoxInQueryBuilder.Parameters.Count];
+                commandParameterValues = new string[SelectedCommandFromComboBoxInQueryBuilder.Parameters.Count];
 
-            _currentQuery.CommandName = SelectedComboBoxCommand.CommandText;
+                _currentQuery.QueryDescription = QueryDescription;
+                _currentQuery.QueryName = QueryName;
+                _currentQuery.PSCommandName = SelectedCommandFromComboBoxInQueryBuilder.CommandText;
 
-            int i = 0;
-            foreach (CommandParameter commandParameter in SelectedComboBoxCommand.Parameters)
-            {
-                commandParameters[i] = commandParameter.Name;
-                commandParameterValues[i] = commandParameter.Value.ToString();
-                i++;
+                for (int i = 0; i < SelectedCommandFromComboBoxInQueryBuilder.Parameters.Count; i++)
+                {
+                    CommandParameter commandParameter = SelectedCommandFromComboBoxInQueryBuilder.Parameters[i];
+
+                    commandParameters[i] = commandParameter.Name;
+                    commandParameterValues[i] = commandParameter.Value.ToString()!;
+                }
+                _currentQuery.PSCommandParameters = commandParameters;
+                _currentQuery.PSCommandParameterValues = commandParameterValues;
             }
-            _currentQuery.CommandParameters = commandParameters;
-            _currentQuery.CommandParametersValues = commandParameterValues;
         }
+        // TODO: Possibly provide more comprehensive error handling.
         catch (Exception ex)
         {
             Trace.WriteLine(ex);
         }
     }
 
-    /// <summary>
-    /// Removes the parameter box after adding them
-    /// </summary>
-    /// <param name="_">This is the CommandParameter object that this command is tied to</param>
-    private void RemoveParameterComboBox(object _)
+    private void RemoveCommandParameterComboBoxInQueryBuilder(object _)
     {
-        if (DynamicParametersCollection.Count != 0)
+        if (DynamicallyAvailableADCommandParametersComboBox.Count != 0)
         {
-            DynamicParametersCollection.RemoveAt(DynamicParametersCollection.Count - 1);
-            DynamicParameterValuesCollection.RemoveAt(DynamicParameterValuesCollection.Count - 1);
+            DynamicallyAvailableADCommandParametersComboBox.RemoveAt(
+                DynamicallyAvailableADCommandParametersComboBox.Count - 1);
+            DynamicallyAvailableADCommandParameterValueTextBox.RemoveAt(
+                DynamicallyAvailableADCommandParameterValueTextBox.Count - 1);
+        }
+        else
+        {
+            MessageBox.Show("There are no parameters to remove.",
+                            "Warning",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Warning);
         }
     }
 
-    /// <summary>
-    /// This method will serialize the command and add it to the list of buttons.
-    /// TODO: Fix any and all warnings about possible null values.
-    /// TODO: Remove any unused variables.
-    /// </summary>
-    /// <param name="commandParameter">This is not used but necessary for the relay command</param>
-    private void SaveCustomQueries(object commandParameter)
+    private void SaveQuery(object commandParameter)
     {
-        if (SelectedComboBoxCommand is null)
+        if (SelectedCommandFromComboBoxInQueryBuilder is null)
         {
             Trace.WriteLine("No command selected.");
             MessageBox.Show("To save a query, you must first select a command.",
@@ -670,36 +676,26 @@ private void SaveCustomQueries(object commandParameter)
             return;
         }
 
-        if (_isEditing is not null && EditingEnabled == true)
+        if (_isEditing is not null && QueryEditingEnabled)
         {
             // CustomQueries.query editingQuery = _customQuery.Queries.Find(item => item == isEditing);
             GetCurrentQuery();
+            Trace.WriteLine(_customQuery.Queries.IndexOf(_isEditing));
             _customQuery.Queries[_customQuery.Queries.IndexOf(_isEditing)] = _currentQuery;
-            _customQuery.SerializeMethod();
+            _customQuery.SaveQueriesToJson();
             _isEditing = null;
-            EditingEnabled = false;
+            QueryEditingEnabled = false;
         }
         else
         {
             // Try to get the content within the drop downs
             try
             {
-                int i = 0;
-                foreach (var comboBoxData in DynamicParametersCollection)
-                {
-                    // string selectedItem = comboBoxData.SelectedParameter;
-                    // Need to look at this to see if it is working with the object type and then serialize it
-                    // Trace.WriteLine(DynamicParameterValuesCollection[i].SelectedParameterValue);
-
-                    SelectedComboBoxCommand.Parameters.Add(
-                        new CommandParameter(comboBoxData.SelectedParameter,
-                                             DynamicParameterValuesCollection[i].SelectedParameterValue));
-                    i++;
-                }
+                UpdateSelectedCommand();
 
-                _customQuery.SerializeCommand(SelectedComboBoxCommand, QueryName, QueryDescription);
+                _customQuery.SerializeCommand(SelectedCommandFromComboBoxInQueryBuilder, QueryName, QueryDescription);
 
-                Button newButton = CreateCustomButton();
+                Button newButton = CreateQueryButtonInStackPanel();
 
                 QueryButtonStackPanel.Add(newButton);
             }
@@ -710,37 +706,48 @@ private void SaveCustomQueries(object commandParameter)
         }
     }
 
-    /// <summary>
-    /// This method will clear the query builder and reset the fields to their default values
-    /// </summary>
-    /// <param name="_">Object that the command is tied to</param>
     private void ClearQueryBuilder(object _)
     {
-        SelectedComboBoxCommand = null;
-        DynamicParametersCollection.Clear();
-        DynamicParameterValuesCollection.Clear();
+        if (SelectedCommandFromComboBoxInQueryBuilder is null &&
+            DynamicallyAvailableADCommandParametersComboBox.Count == 0)
+        {
+            MessageBox.Show("The query builder is already clear.",
+                            "Information",
+                            MessageBoxButton.OK,
+                            MessageBoxImage.Information);
+            return;
+        }
+
+        // Display a gui box confirming if the user wants to confirm the clear
+        MessageBoxResult result = MessageBox.Show("Are you sure you want to clear the query builder?",
+                                                  "Warning",
+                                                  MessageBoxButton.YesNo,
+                                                  MessageBoxImage.Warning,
+                                                  MessageBoxResult.No);
+
+        // If the user selects yes, clear the console
+        if (result == MessageBoxResult.Yes)
+        {
+            SelectedCommandFromComboBoxInQueryBuilder = null;
+            DynamicallyAvailableADCommandParametersComboBox.Clear();
+            DynamicallyAvailableADCommandParameterValueTextBox.Clear();
+        }
     }
 
-    /// <summary>
-    /// This method is for creating buttons, right now it creates it off of the current/selectedcommand parameters but
-    /// could be changed to also do it from the query list.
-    /// TODO: Change method name???
-    /// </summary>
-    /// <returns>This method returns a button that has been customized for the custom query list</returns>
-    private Button CreateCustomButton(Query query = null)
+    private Button CreateQueryButtonInStackPanel(Query? query = null)
     {
-        Button newButton = new Button();
+        Button newButton = new();
 
         if (query != null)
         {
             newButton.Height = 48;
-            newButton.Content = (string.IsNullOrEmpty(query.QueryName) ? query.CommandName : query.QueryName);
+            newButton.Content = (string.IsNullOrEmpty(query.QueryName) ? query.PSCommandName : query.QueryName);
             newButton.Tag = query;
         }
         else
         {
-            //Check for null
-            if (SelectedComboBoxCommand is null)
+            // Check for null
+            if (SelectedCommandFromComboBoxInQueryBuilder is null)
             {
                 Trace.WriteLine("No command selected.");
                 MessageBox.Show("To save a query, you must first select a command.",
@@ -752,24 +759,30 @@ private Button CreateCustomButton(Query query = null)
 
             GetCurrentQuery();
             newButton.Height = 48;
-            newButton.Content = (QueryName.Length != 0 ? QueryName : SelectedComboBoxCommand.CommandText);
+            newButton.Content =
+                QueryName.Length != 0 ? QueryName : SelectedCommandFromComboBoxInQueryBuilder.CommandText;
             newButton.Tag = _currentQuery;
         }
 
-        // Button newButton =
-        // new() { Height = 48, Content = QueryName.Length != 0 ? QueryName : SelectedComboBoxCommand.CommandText, Tag =
-        // _currentQuery };
-
         // Want to add right click context menu to each button
         ContextMenu contextMenu = new();
 
         MenuItem menuItem1 =
-            new() { Header = "Execute", Command = ExecuteCommandButtonRelay, CommandParameter = newButton };
+            new() { Header = "Execute", Command = ExecuteQueryFromQueryStackPanelRelay, CommandParameter = newButton };
+
+        MenuItem outputToCsv = new() { Header = "Output to CSV", Command = OutputToCsvFileRelay };
+        MenuItem outputToText = new() { Header = "Output to Text", Command = OutputToTextFileRelay };
+        MenuItem outputToConsole = new() { Header = "Execute to Console", Command = ExecuteQueryFromQueryBuilderRelay };
 
-        MenuItem menuItem2 = new() { Header = "Edit", Command = EditCustomQueryRelay, CommandParameter = newButton };
+        menuItem1.Items.Add(outputToCsv);
+        menuItem1.Items.Add(outputToText);
+        menuItem1.Items.Add(outputToConsole);
+
+        MenuItem menuItem2 =
+            new() { Header = "Edit", Command = EditQueryFromQueryStackPanelRelay, CommandParameter = newButton };
 
         MenuItem menuItem3 =
-            new() { Header = "Delete", Command = DeleteCustomQueryRelay, CommandParameter = newButton };
+            new() { Header = "Delete", Command = DeleteQueryFromQueryStackPanelRelay, CommandParameter = newButton };
 
         // Add menu item to the context menu
         contextMenu.Items.Add(menuItem1);
@@ -783,10 +796,6 @@ private Button CreateCustomButton(Query query = null)
 
     // [[ Event Handlers ]] --------------------------------------------------------- //
 
-    /// <summary>
-    /// Handles property change notifications.
-    /// </summary>
-    /// <param name="propertyName">Name of the property that changed.</param>
     private void OnPropertyChanged(string propertyName)
     {
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
diff --git a/ActiveDirectoryQuerier/PSSaveOptions.cs b/ActiveDirectoryQuerier/PSSaveOptions.cs
deleted file mode 100644
index e089b42..0000000
--- a/ActiveDirectoryQuerier/PSSaveOptions.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-using System.Management.Automation.Internal;
-using System.Management.Automation.Runspaces;
-using ActiveDirectoryQuerier.PowerShell;
-
-namespace ActiveDirectoryQuerier;
-
-/// <summary>
-/// This class *might* be used for housing the save options
-/// TODO: Delete this class if it is not used...
-/// </summary>
-public class PSSaveOptions
-{
-    /// <summary>
-    /// This would be to output the query to a csv, will need to eventually adapt to a guicommand as well most likely
-    /// </summary>
-    /// <param name="commandString"> This is the internal command that we want to output to a csv </param>
-    public Command OutputToCsv(Command commandString)
-    {
-        throw new NotImplementedException();
-    }
-
-    /// <summary>
-    /// This would be to have the query output to a message box
-    /// </summary>
-    public InternalCommand OutputToMessageBox(InternalCommand commandSting)
-    {
-        throw new NotImplementedException();
-    }
-
-    /// <summary>
-    /// This will be to save the query to a text file
-    /// </summary>
-    public void SaveToTxt(ReturnValues results)
-    {
-        throw new NotImplementedException();
-    }
-
-    /// <summary>
-    /// This is used for saving the file to a PS1 powershell file
-    /// </summary>
-    public void SaveToPS(ReturnValues results)
-    {
-        throw new NotImplementedException();
-    }
-}
diff --git a/ActiveDirectoryQuerier/PowerShell/ActiveDirectoryCommands.cs b/ActiveDirectoryQuerier/PowerShell/ActiveDirectoryCommands.cs
deleted file mode 100644
index 7dfbdc1..0000000
--- a/ActiveDirectoryQuerier/PowerShell/ActiveDirectoryCommands.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using System.Collections.ObjectModel;
-using System.Management.Automation;
-using System.Management.Automation.Runspaces;
-using System.Windows;
-
-namespace ActiveDirectoryQuerier.PowerShell;
-
-/// <summary>
-/// Provides functionalities related to the ActiveDirectory PowerShell module.
-/// </summary>
-public static class ActiveDirectoryCommands
-{
-    /// <summary>
-    /// Retrieves a list of commands available in the ActiveDirectory PowerShell module.
-    /// </summary>
-    /// <returns>
-    /// An ObservableCollection of Command objects representing each command in the ActiveDirectory module.
-    /// </returns>
-    /// <exception cref="InvalidPowerShellStateException">
-    /// Thrown if an error occurs during the execution of the PowerShell command.
-    /// </exception>
-    public static async Task<ObservableCollection<Command>> GetActiveDirectoryCommands()
-    {
-        Command command = new("Get-Command");
-        command.Parameters.Add("Module", "ActiveDirectory");
-        PowerShellExecutor powerShellExecutor = new();
-        ObservableCollection<Command> commandList = new();
-        ReturnValues commandListTemp = await powerShellExecutor.ExecuteAsync(command);
-
-        // NOTE: This is more of an internal error...
-        // TODO: Provide a more detailed error message??? Maybe log the error to a file???
-        if (commandListTemp.HadErrors)
-        {
-            MessageBox.Show(string.Join(" ", commandListTemp.StdErr),
-                            "Warning",
-                            MessageBoxButton.OK,
-                            MessageBoxImage.Error);
-            throw new InvalidPowerShellStateException(
-                "An error occurred while retrieving the ActiveDirectory commands.");
-        }
-
-        foreach (var cmd in commandListTemp.StdOut)
-        {
-            commandList.Add(new Command(cmd));
-        }
-
-        return commandList;
-    }
-}
diff --git a/ActiveDirectoryQuerier/PowerShell/CommandParameters.cs b/ActiveDirectoryQuerier/PowerShell/CommandParameters.cs
deleted file mode 100644
index 60fe965..0000000
--- a/ActiveDirectoryQuerier/PowerShell/CommandParameters.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Management.Automation;
-using System.Management.Automation.Runspaces;
-
-namespace ActiveDirectoryQuerier.PowerShell;
-
-/// <summary>
-/// Manages and provides the parameters available for a given PowerShell command.
-/// TODO: Figure out what to do with the Async and non-Async methods! Too much duplicate code..
-/// </summary>
-public class CommandParameters : ICommandParameters
-{
-    private readonly ObservableCollection<string> _possibleParameters = new();
-
-    /// <summary>
-    /// Gets the collection of possible parameters for a command.
-    /// </summary>
-    /// <note>
-    /// I realize that this isn't a very clean way of doing things, but it's the best I could come up with at the time.
-    /// </note>
-    /// <exception cref="InvalidOperationException">Thrown when the collection has not been populated yet.</exception>
-    public ObservableCollection<string> PossibleParameters
-    {
-        get {
-            if (_possibleParameters.Count == 0)
-            {
-                throw new InvalidOperationException(
-                    "'PossibleParameters' has not been populated via 'LoadCommandParametersAsync'.");
-            }
-
-            return _possibleParameters;
-        }
-    }
-
-    /// <summary>
-    /// Asynchronously loads the possible parameters for the specified command into the '_possibleParameters'
-    /// collection.
-    /// </summary>
-    /// <param name="commandObject">The PowerShell command object whose parameters are to be loaded.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    public async Task LoadCommandParametersAsync(Command? commandObject)
-    {
-        // commandObject can be null if the user attempts to select an ActiveDirectory command that doesn't exist.
-        // More specifically, if the entered command doesn't exist in the ActiveDirectoryCommandsList in
-        // MainWindowViewModel.cs, commandObject will be null, causing an exception to be thrown, crashing the program.
-        if (commandObject is null)
-        {
-            Trace.WriteLine("Error: commandObject is null");
-            _possibleParameters.Add("No valid command provided");
-            return;
-        }
-
-        if (_possibleParameters.Count == 0)
-        {
-            using var powerShell = System.Management.Automation.PowerShell.Create();
-            string commandString =
-                $"Get-Command {commandObject.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{ $_.Keys }}";
-
-            powerShell.Commands.Clear();
-            powerShell.AddScript(commandString);
-            PSDataCollection<PSObject> result = await powerShell.InvokeAsync();
-
-            foreach (PSObject cmd in result)
-            {
-                _possibleParameters.Add($"-{cmd}");
-            }
-        }
-    }
-
-    /// <summary>
-    /// Loads the possible parameters for the specified command into the '_possibleParameters' collection.
-    /// </summary>
-    /// <param name="commandObject">The PowerShell command object whose parameters are to be loaded.</param>
-    void ICommandParameters.LoadCommandParameters(Command? commandObject)
-    {
-        // commandObject can be null if the user attempts to select an ActiveDirectory command that doesn't exist.
-        // More specifically, if the entered command doesn't exist in the ActiveDirectoryCommandsList in
-        // MainWindowViewModel.cs, commandObject will be null, causing an exception to be thrown, crashing the program.
-        if (commandObject is null)
-        {
-            Trace.WriteLine("Error: commandObject is null");
-            _possibleParameters.Add("No valid command provided");
-            return;
-        }
-
-        if (_possibleParameters.Count == 0)
-        {
-            using var powerShell = System.Management.Automation.PowerShell.Create();
-            string commandString =
-                $"Get-Command {commandObject.CommandText} | Select -ExpandProperty Parameters | ForEach-Object {{$_.Keys }}";
-
-            powerShell.Commands.Clear();
-            powerShell.AddScript(commandString);
-            Collection<PSObject> result = powerShell.Invoke();
-
-            foreach (PSObject cmd in result)
-            {
-                _possibleParameters.Add($"-{cmd}");
-            }
-        }
-    }
-}
diff --git a/ActiveDirectoryQuerier/PowerShell/CustomQueries.cs b/ActiveDirectoryQuerier/PowerShell/CustomQueries.cs
deleted file mode 100644
index d0cbeb1..0000000
--- a/ActiveDirectoryQuerier/PowerShell/CustomQueries.cs
+++ /dev/null
@@ -1,182 +0,0 @@
-using System.Diagnostics;
-using System.IO;
-using System.Management.Automation.Runspaces;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace ActiveDirectoryQuerier.PowerShell;
-
-/// <summary>
-/// This class is used to save a json file named "CustomQueries.dat" inside of
-/// \ActiveDirectoryQuerier\ActiveDirectoryQuerier\bin\Debug\net6.0-windows This
-/// </summary>
-internal class CustomQueries
-{
-    public class Query
-    {
-        /// <summary>
-        /// Command that should help with Binding the command to the query for the buttons sake
-        /// </summary>
-        [JsonIgnore]
-        public Command? Command { get; set; }
-
-        /// <summary>
-        /// Used for serializing the Command Name
-        /// </summary>
-        public string CommandName { get; set; }
-
-        /// <summary>
-        /// Used for Serializing the Commands parameters
-        /// </summary>
-        public string[] CommandParameters { get; set; }
-
-        /// <summary>
-        /// Used for Serializing the Commands parameters
-        /// </summary>
-        public string[] CommandParametersValues { get; set; }
-
-        /// <summary>
-        /// Used for the name of the custom Query
-        /// </summary>
-        public string QueryName { get; set; }
-
-        /// <summary>
-        /// Used for the Custom Queries Description
-        /// </summary>
-        public string QueryDescription { get; set; }
-
-        // Constructor for the query class
-        /*public Query(string cN, string[] commandParams)
-        {
-            this.CommandName = cN;
-            this.CommandParameters = commandParams;
-        }*/
-
-        /// <summary>
-        /// Constructor for the query class
-        /// TODO: Fix any and all warnings about possible null values.
-        /// </summary>
-        /// <param name="cN"></param>
-        public Query(string cN)
-        {
-            CommandName = cN;
-        }
-
-        /// <summary>
-        /// Empty constructor for the query class
-        /// TODO: Fix any and all warnings about possible null values.
-        /// </summary>
-        public Query()
-        { }
-    }
-
-    public List<Query> Queries = new();
-
-    /// <summary>
-    /// This a variable for feeding options to the Json serializer
-    /// </summary>
-    private static readonly JsonSerializerOptions _options = new() {
-        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-        WriteIndented = true,
-        ReferenceHandler = ReferenceHandler.Preserve,
-    };
-
-    /// <summary>
-    /// This takes the Queries List and serializes it to a file
-    /// </summary>
-    public void SerializeMethod()
-    {
-        try
-        {
-            string json = JsonSerializer.Serialize(Queries, _options);
-            File.WriteAllText("CustomQueries.dat", json);
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
-    }
-
-    /// <summary>
-    /// This method is for serializing a command type, so it converts the type to a query and then serializes it
-    /// TODO: Fix any and all warnings about possible null values.
-    /// </summary>
-    public void SerializeCommand(Command? cmnd, string queryName, string queryDescription)
-    {
-        Trace.WriteLine(cmnd.Parameters.Count);
-
-        string[] commandParameters = new string[cmnd.Parameters.Count];
-        string[] commandParameterValues = new string[cmnd.Parameters.Count];
-        Query newQuery = new Query(cmnd.CommandText);
-
-        // Set name and description
-        newQuery.QueryName = queryName;
-        newQuery.QueryDescription = queryDescription;
-
-        // Iterate over the parameters and add them to the string
-
-        for (int i = 0; i < cmnd.Parameters.Count; i++)
-        {
-            CommandParameter param = cmnd.Parameters[i];
-
-            Trace.WriteLine(param.Name + " Value: ");
-
-            commandParameters[i] = param.Name;
-            commandParameterValues[i] = param.Value.ToString();
-        }
-        newQuery.CommandParameters = commandParameters;
-        newQuery.CommandParametersValues = commandParameterValues;
-
-        Queries.Add(newQuery);
-
-        CustomQueries customQueries = new CustomQueries();
-        customQueries.SerializeMethod();
-        try
-        {
-            string json = JsonSerializer.Serialize(Queries, _options);
-            Trace.WriteLine(json);
-            File.WriteAllText("CustomQueries.dat", json);
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
-    }
-    /// <summary>
-    /// This method Loads the string from the saved file "CustomQueries.dat" then gives it to the Queries List
-    /// TODO: Fix any and all warnings about possible null values.
-    /// </summary>
-    public void LoadData()
-    {
-        try
-        {
-            // Opens file and reads it then adds the json to the Queries List
-            string json = File.ReadAllText("CustomQueries.dat");
-            Queries = JsonSerializer.Deserialize<List<Query>>(json, _options);
-
-            // Now we want to fill the command variable for each query
-            foreach (Query q in Queries)
-            {
-                Command? command = new Command(q.CommandName);
-
-                // Check if there are parameters, and if there are add them to the list
-                if (q.CommandParameters != null)
-                {
-                    for (int i = 0; i < q.CommandParameters.Length; i++)
-                    {
-                        command.Parameters.Add(q.CommandParameters[i], q.CommandParametersValues[i]);
-                        // the values are working then we will use this
-                        //command.Parameters.Add(q.CommandParameters[i]);
-                    }
-                }
-
-                // set the query command to the command
-                q.Command = command;
-            }
-        }
-        catch (Exception ex)
-        {
-            Trace.WriteLine(ex);
-        }
-    }
-}
diff --git a/ActiveDirectoryQuerier/PowerShell/ICommandParameters.cs b/ActiveDirectoryQuerier/PowerShell/ICommandParameters.cs
deleted file mode 100644
index d765e23..0000000
--- a/ActiveDirectoryQuerier/PowerShell/ICommandParameters.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-using System.Management.Automation.Runspaces;
-
-namespace ActiveDirectoryQuerier.PowerShell;
-
-public interface ICommandParameters
-{
-    void LoadCommandParameters(Command? commandObject);
-}
diff --git a/ActiveDirectoryQuerier/PowerShell/PSExecutor.cs b/ActiveDirectoryQuerier/PowerShell/PSExecutor.cs
new file mode 100644
index 0000000..8ac3ecf
--- /dev/null
+++ b/ActiveDirectoryQuerier/PowerShell/PSExecutor.cs
@@ -0,0 +1,108 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Management.Automation;
+using System.Management.Automation.Runspaces;
+using System.Text;
+
+namespace ActiveDirectoryQuerier.PowerShell;
+
+// ReSharper disable once InconsistentNaming
+public class PSExecutor
+{
+    private readonly System.Management.Automation.PowerShell _powerShell;
+
+    public PSExecutor()
+    {
+        _powerShell = System.Management.Automation.PowerShell.Create();
+
+        // Import the ActiveDirectory module to ensure that the ActiveDirectory commands are available.
+        _powerShell.AddScript("Import-Module ActiveDirectory;");
+        _powerShell.Invoke();
+        _powerShell.Commands.Clear();
+    }
+
+    private void AssembleFullCommand(Command psCommand)
+    {
+        ArgumentNullException.ThrowIfNull(psCommand);
+
+        _powerShell.Commands.AddCommand(psCommand.CommandText);
+
+        foreach (var parameter in psCommand.Parameters)
+        {
+            _powerShell.Commands.AddParameter(parameter.Name, parameter.Value);
+        }
+    }
+
+    public PSOutput Execute(Command psCommand)
+    {
+        try
+        {
+            _powerShell.Commands.Clear();
+            AssembleFullCommand(psCommand);
+
+            Collection<PSObject> results = _powerShell.Invoke();
+
+            return ProcessExecutionResults(results);
+        }
+        catch (Exception exception)
+        {
+            return HandleExecutionException(exception);
+        }
+    }
+
+    public async Task<PSOutput> ExecuteAsync(Command command)
+    {
+        try
+        {
+            _powerShell.Commands.Clear();
+            AssembleFullCommand(command);
+
+            PSDataCollection<PSObject> results = await _powerShell.InvokeAsync();
+
+            return await ProcessExecutionResultsAsync(results);
+        }
+        catch (Exception exception)
+        {
+            return HandleExecutionException(exception);
+        }
+    }
+
+    private PSOutput ProcessExecutionResults(IEnumerable<PSObject> results)
+    {
+        PSOutput psOutput = new();
+
+        if (_powerShell.HadErrors)
+        {
+            foreach (ErrorRecord error in _powerShell.Streams.Error)
+            {
+                psOutput.StdErr.Add($"Error: {error}");
+            }
+        }
+        else
+        {
+            foreach (PSObject result in results)
+            {
+                psOutput.StdOut.Add(result.ToString());
+            }
+        }
+
+        return psOutput;
+    }
+
+    private Task<PSOutput> ProcessExecutionResultsAsync(IEnumerable<PSObject> results)
+    {
+        return Task.FromResult(ProcessExecutionResults(results));
+    }
+
+    private PSOutput HandleExecutionException(Exception exception)
+    {
+        StringBuilder errorMessage = new();
+
+        errorMessage.AppendLine("An error occurred while executing the PowerShell command:");
+        errorMessage.AppendLine(exception.Message);
+        errorMessage.AppendLine(exception.StackTrace);
+        Debug.WriteLine(errorMessage.ToString());
+
+        return new PSOutput { StdErr = { errorMessage.ToString() } };
+    }
+}
diff --git a/ActiveDirectoryQuerier/PowerShell/ReturnValues.cs b/ActiveDirectoryQuerier/PowerShell/PSOutput.cs
similarity index 86%
rename from ActiveDirectoryQuerier/PowerShell/ReturnValues.cs
rename to ActiveDirectoryQuerier/PowerShell/PSOutput.cs
index afcad90..0375e48 100644
--- a/ActiveDirectoryQuerier/PowerShell/ReturnValues.cs
+++ b/ActiveDirectoryQuerier/PowerShell/PSOutput.cs
@@ -2,9 +2,10 @@ namespace ActiveDirectoryQuerier.PowerShell;
 
 /// <summary>
 /// Encapsulates the return values from a PowerShell command, separated into standard output (StdOut) and standard
-/// error (StdErr).
+/// error output (StdErr).
 /// </summary>
-public record ReturnValues
+// ReSharper disable once InconsistentNaming
+public record PSOutput
 {
     /// <summary>
     /// Gets a value indicating whether the command execution resulted in any errors.
@@ -23,7 +24,7 @@ public record ReturnValues
     public List<string> StdOut { get; } = new();
 
     /// <summary>
-    /// Gets the standard error (StdErr) of the PowerShell command execution.
+    /// Gets the standard error output (StdErr) of the PowerShell command execution.
     /// </summary>
     /// <value>
     /// A list of strings representing the standard error output from the command.
diff --git a/ActiveDirectoryQuerier/PowerShell/PowerShellExecutor.cs b/ActiveDirectoryQuerier/PowerShell/PowerShellExecutor.cs
deleted file mode 100644
index ed9fff7..0000000
--- a/ActiveDirectoryQuerier/PowerShell/PowerShellExecutor.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Management.Automation;
-using System.Management.Automation.Runspaces;
-using System.Text;
-
-namespace ActiveDirectoryQuerier.PowerShell;
-
-/// <summary>
-/// Manages execution of PowerShell commands, providing both synchronous and asynchronous execution methods.
-/// </summary>
-public class PowerShellExecutor
-{
-    private readonly System.Management.Automation.PowerShell _powerShell;
-
-    /// <summary>
-    /// Initializes a new instance of the PowerShellExecutor class and imports the ActiveDirectory module.
-    /// </summary>
-    public PowerShellExecutor()
-    {
-        _powerShell = System.Management.Automation.PowerShell.Create();
-
-        _powerShell.AddScript("Import-Module ActiveDirectory;");
-        _powerShell.Invoke();
-        _powerShell.Commands.Clear();
-    }
-
-    /// <summary>
-    /// Prepares a PowerShell command for execution.
-    /// </summary>
-    /// <param name="command">The command to be prepared for execution.</param>
-    private void PrepareCommand(Command? command)
-    {
-        // TODO: Might change to just return if command is null...
-        if (command is null)
-        {
-            throw new ArgumentNullException(nameof(command));
-        }
-
-        _powerShell.Commands.AddCommand(command.CommandText);
-        foreach (var parameter in command.Parameters)
-        {
-            _powerShell.Commands.AddParameter(parameter.Name, parameter.Value);
-        }
-    }
-
-    /// <summary>
-    /// Executes a PowerShell command synchronously and returns the results.
-    /// </summary>
-    /// <param name="command">The command to be executed.</param>
-    /// <returns>A ReturnValues object containing the results of the command execution.</returns>
-    public ReturnValues Execute(Command? command)
-    {
-        try
-        {
-            PrepareCommand(command);
-
-            Collection<PSObject> results = _powerShell.Invoke();
-
-            return ProcessPowerShellResults(results);
-        }
-        catch (Exception ex)
-        {
-            return ExecutionExceptionHandler(ex);
-        }
-    }
-
-    /// <summary>
-    /// Executes a PowerShell command asynchronously and returns the results.
-    /// </summary>
-    /// <param name="command">The command to be executed.</param>
-    /// <returns>A task containing a ReturnValues object with the results of the command execution.</returns>
-    public async Task<ReturnValues> ExecuteAsync(Command? command)
-    {
-        try
-        {
-            PrepareCommand(command);
-
-            PSDataCollection<PSObject> results = await _powerShell.InvokeAsync();
-
-            return await ProcessPowerShellResultsAsync(results);
-        }
-        catch (Exception ex)
-        {
-            return ExecutionExceptionHandler(ex);
-        }
-    }
-
-    /// <summary>
-    /// Handles exceptions that occur during the execution of a PowerShell command.
-    /// </summary>
-    /// <param name="ex">The exception that occurred during the execution of the PowerShell command.</param>
-    /// <returns>A ReturnValues object containing the exception details.</returns>
-    private ReturnValues ExecutionExceptionHandler(Exception ex)
-    {
-        StringBuilder sb = new();
-
-        sb.AppendLine("An error occurred while executing the PowerShell command:");
-        sb.AppendLine(ex.Message);
-        sb.AppendLine(ex.StackTrace);
-        Debug.WriteLine(sb.ToString());
-
-        return new ReturnValues { StdErr = { sb.ToString() } };
-    }
-
-    /// <summary>
-    /// Processes and formats the results of a PowerShell command execution synchronously.
-    /// </summary>
-    /// <param name="results">The results of the PowerShell command execution.</param>
-    /// <returns>A ReturnValues object containing the processed results.</returns>
-    private ReturnValues ProcessPowerShellResults(IEnumerable<PSObject> results)
-    {
-        ReturnValues returnValues = new();
-
-        if (_powerShell.HadErrors)
-        {
-            foreach (var error in _powerShell.Streams.Error)
-            {
-                returnValues.StdErr.Add($"Error: {error}");
-            }
-        }
-        else
-        {
-            foreach (var result in results)
-            {
-                returnValues.StdOut.Add(result.ToString());
-            }
-        }
-
-        return returnValues;
-    }
-
-    /// <summary>
-    /// Processes and formats the results of a PowerShell command execution asynchronously.
-    /// </summary>
-    /// <param name="results">The results of the PowerShell command execution.</param>
-    /// <returns>A task containing a ReturnValues object with the processed results.</returns>
-    private Task<ReturnValues> ProcessPowerShellResultsAsync(IEnumerable<PSObject> results)
-    {
-        return Task.FromResult(ProcessPowerShellResults(results));
-    }
-}
diff --git a/ActiveDirectoryQuerier/Queries/CustomQueries.cs b/ActiveDirectoryQuerier/Queries/CustomQueries.cs
new file mode 100644
index 0000000..8d5f04c
--- /dev/null
+++ b/ActiveDirectoryQuerier/Queries/CustomQueries.cs
@@ -0,0 +1,138 @@
+using System.Diagnostics;
+using System.IO;
+using System.Management.Automation.Runspaces;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Windows;
+
+namespace ActiveDirectoryQuerier.Queries;
+
+/// <summary>
+/// This class is used to save a json file named "CustomQueries.json" inside of
+/// \ActiveDirectoryQuerier\ActiveDirectoryQuerier\bin\Debug\net6.0-windows This
+/// </summary>
+public class CustomQueries
+{
+    public List<Query> Queries { get; private set; } = new();
+    public string CustomQueryFileLocation { get; set; } = string.Empty;
+
+    /// <summary>
+    /// This a variable for feeding options to the Json serializer
+    /// </summary>
+    private static readonly JsonSerializerOptions _options = new() {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = true,
+        ReferenceHandler = ReferenceHandler.Preserve,
+    };
+
+    /// <summary>
+    /// This takes the Queries List and serializes it to a file
+    /// </summary>
+    public void SaveQueriesToJson()
+    {
+        try
+        {
+            string serializedJsonQueries = JsonSerializer.Serialize(Queries, _options);
+            File.WriteAllText(CustomQueryFileLocation == "" ? "CustomQueries.json" : CustomQueryFileLocation,
+                              serializedJsonQueries);
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show(ex.Message);
+        }
+    }
+
+    /// <summary>
+    /// This method is for serializing a command type, so it converts the type to a query and then serializes it
+    /// </summary>
+    /// <param name="psCommand">Command class that you want to serialize</param>
+    /// <param name="queryDescription">Description field of the Query</param>
+    /// <param name="queryName">Query Name</param>
+    public void SerializeCommand(Command? psCommand, string queryName, string queryDescription)
+    {
+        string[] commandParameters = new string[psCommand!.Parameters.Count];
+        string[] commandParameterValues = new string[psCommand.Parameters.Count];
+        Query newQuery = new(psCommand.CommandText) { QueryName = queryName, QueryDescription = queryDescription };
+
+        // Iterate over the parameters and add them to the string
+        for (int i = 0; i < psCommand.Parameters.Count; i++)
+        {
+            CommandParameter param = psCommand.Parameters[i];
+
+            commandParameters[i] = param.Name;
+            commandParameterValues[i] = param.Value.ToString()!;
+        }
+
+        newQuery.PSCommandParameters = commandParameters;
+        newQuery.PSCommandParameterValues = commandParameterValues;
+
+        Queries.Add(newQuery);
+        SaveQueriesToJson();
+
+        try
+        {
+            string serializedJsonQueries = JsonSerializer.Serialize(Queries, _options);
+            if (CustomQueryFileLocation == "")
+            {
+                File.WriteAllText("CustomQueries.json", serializedJsonQueries);
+            }
+            else
+            {
+                File.WriteAllText(CustomQueryFileLocation, serializedJsonQueries);
+            }
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show(ex.Message);
+        }
+    }
+    /// <summary>
+    /// This method Loads the string from the saved file "CustomQueries.dat" then gives it to the Queries List
+    /// </summary>
+    public void LoadData()
+    {
+        try
+        {
+            // Opens file and reads it then adds the json to the Queries List
+            string json;
+            if (CustomQueryFileLocation == "")
+            {
+                if (File.Exists("CustomQueries.json"))
+                {
+                    json = File.ReadAllText("CustomQueries.json");
+                }
+                else
+                {
+                    return;
+                }
+            }
+            else
+            {
+                json = File.ReadAllText(CustomQueryFileLocation);
+            }
+            Queries = JsonSerializer.Deserialize<List<Query>>(json, _options)!;
+
+            // Now we want to fill the command variable for each query
+            foreach (Query query in Queries)
+            {
+                Command psCommand = new Command(query.PSCommandName);
+
+                // Check if there are parameters, and if there are add them to the list
+                if (query.PSCommandParameters != null)
+                {
+                    for (int i = 0; i < query.PSCommandParameters.Length; i++)
+                    {
+                        psCommand.Parameters.Add(query.PSCommandParameters[i], query.PSCommandParameterValues![i]);
+                    }
+                }
+
+                // set the query command to the command
+                query.Command = psCommand;
+            }
+        }
+        catch (Exception exception)
+        {
+            MessageBox.Show(exception.Message);
+        }
+    }
+}
diff --git a/ActiveDirectoryQuerier/Queries/Query.cs b/ActiveDirectoryQuerier/Queries/Query.cs
new file mode 100644
index 0000000..43b965e
--- /dev/null
+++ b/ActiveDirectoryQuerier/Queries/Query.cs
@@ -0,0 +1,53 @@
+using System.Management.Automation.Runspaces;
+using System.Text.Json.Serialization;
+
+namespace ActiveDirectoryQuerier.Queries;
+
+public class Query
+{
+    /// <summary>
+    /// Command that should help with Binding the command to the query for the buttons sake
+    /// </summary>
+    [JsonIgnore]
+    public Command? Command { get; set; }
+
+    /// <summary>
+    /// Used for serializing the Command Name
+    /// </summary>
+    public string? PSCommandName { get; set; }
+
+    /// <summary>
+    /// Used for Serializing the Commands parameters
+    /// </summary>
+    public string[]? PSCommandParameters { get; set; }
+
+    /// <summary>
+    /// Used for Serializing the Commands parameters
+    /// </summary>
+    public string[]? PSCommandParameterValues { get; set; }
+
+    /// <summary>
+    /// Used for the name of the custom Query
+    /// </summary>
+    public string? QueryName { get; set; }
+
+    /// <summary>
+    /// Used for the Custom Queries Description
+    /// </summary>
+    public string? QueryDescription { get; set; }
+
+    /// <summary>
+    /// Constructor for the query class
+    /// </summary>
+    /// <param name="psCommandName">Name of the Command EX. get-adusers</param>
+    public Query(string psCommandName)
+    {
+        PSCommandName = psCommandName;
+    }
+
+    /// <summary>
+    /// Empty constructor for the query class
+    /// </summary>
+    public Query()
+    { }
+}
diff --git a/ActiveDirectoryQuerier/RelayCommand.cs b/ActiveDirectoryQuerier/RelayCommand.cs
deleted file mode 100644
index 29ddc36..0000000
--- a/ActiveDirectoryQuerier/RelayCommand.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-using System.Windows.Input;
-
-namespace ActiveDirectoryQuerier;
-
-/// <summary>
-/// A command whose sole purpose is to relay its functionality to other objects by invoking delegates.
-/// TODO: Remove any unused methods, after some investigation.
-/// </summary>
-/// <note>
-/// I'm unsure if I'm dealing with the nullability warnings correctly, in this situation...
-/// </note>
-public class RelayCommand : ICommand
-{
-    private readonly Action<object> _execute;
-    private readonly Predicate<object?>? _canExecute;
-
-    /// <summary>
-    /// Initializes a new instance of the RelayCommand class.
-    /// </summary>
-    /// <param name="execute">The execution logic.</param>
-    /// <param name="canExecute">The execution status logic.</param>
-    /// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
-    public RelayCommand(Action<object> execute, Predicate<object?>? canExecute = null)
-    {
-        _execute = execute;
-        _canExecute = canExecute;
-    }
-
-    /// <summary>
-    /// Determines whether the command can execute in its current state.
-    /// </summary>
-    /// <param name="parameter">
-    /// Data used by the command. If the command does not require data to be passed, this object can be set to null.
-    /// </param>
-    /// <returns>true if this command can be executed; otherwise, false.</returns>
-    public bool CanExecute(object? parameter)
-    {
-        return _canExecute?.Invoke(parameter) ?? true;
-    }
-
-    /// <summary>
-    /// Executes the command.
-    /// </summary>
-    /// <param name="parameter">
-    /// Data used by the command. If the command does not require data to be passed, this object can be set to null.
-    /// </param>
-    public void Execute(object? parameter)
-    {
-        // For now, we are ignoring the warning about the parameter being null.
-        _execute(parameter!);
-    }
-
-    /// <summary>
-    /// Occurs when changes occur that affect whether the command should execute.
-    /// </summary>
-    public event EventHandler? CanExecuteChanged
-    {
-        add => CommandManager.RequerySuggested += value;
-        remove => CommandManager.RequerySuggested -= value;
-    }
-
-    /// <summary>
-    /// Method to call when the command's ability to execute has changed.
-    /// </summary>
-    public void RaiseCanExecuteChanged()
-    {
-        CommandManager.InvalidateRequerySuggested();
-    }
-}
diff --git a/ActiveDirectoryQuerier/ViewModels/ComboBoxParameterViewModel.cs b/ActiveDirectoryQuerier/ViewModels/ComboBoxParameterViewModel.cs
new file mode 100644
index 0000000..9f60bbb
--- /dev/null
+++ b/ActiveDirectoryQuerier/ViewModels/ComboBoxParameterViewModel.cs
@@ -0,0 +1,50 @@
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+
+namespace ActiveDirectoryQuerier.ViewModels;
+
+/// <summary>
+/// ViewModel for a ComboBox that displays possible parameters for a PowerShell command.
+/// It is used when adding a new parameter slot to a command in the GUI.
+/// </summary>
+/// TODO: Place class into ViewModel folder.
+public sealed class ComboBoxParameterViewModel : INotifyPropertyChanged
+{
+    public event PropertyChangedEventHandler? PropertyChanged;
+    private ObservableCollection<string> _availableParameters = new();
+    private string _selectedParameter = string.Empty;
+
+    public ComboBoxParameterViewModel(ObservableCollection<string> possibleParameters)
+    {
+        AvailableParameters = possibleParameters ?? throw new ArgumentNullException(nameof(possibleParameters));
+    }
+
+    public string SelectedParameter
+    {
+        get => _selectedParameter;
+        set {
+            if (_selectedParameter != value)
+            {
+                _selectedParameter = value;
+                OnPropertyChanged(nameof(SelectedParameter));
+            }
+        }
+    }
+
+    public ObservableCollection<string> AvailableParameters
+    {
+        get => _availableParameters;
+        set {
+            if (_availableParameters != value)
+            {
+                _availableParameters = value;
+                OnPropertyChanged(nameof(AvailableParameters));
+            }
+        }
+    }
+
+    private void OnPropertyChanged(string propertyName)
+    {
+        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+}
diff --git a/ActiveDirectoryQuerier/ViewModels/RelayCommand.cs b/ActiveDirectoryQuerier/ViewModels/RelayCommand.cs
new file mode 100644
index 0000000..199f9db
--- /dev/null
+++ b/ActiveDirectoryQuerier/ViewModels/RelayCommand.cs
@@ -0,0 +1,45 @@
+using System.Windows.Input;
+
+namespace ActiveDirectoryQuerier.ViewModels;
+
+/// <summary>
+/// A command whose sole purpose is to relay its functionality to other objects by invoking delegates.
+/// </summary>
+/// <note>
+/// This is a very basic setup of the RelayCommand class. I imagine that this class can be expanded and improved upon.
+/// </note>
+public class RelayCommand : ICommand
+{
+    private readonly Action<object> _execute;
+    private readonly Predicate<object?>? _canExecute;
+
+    /// <param name="execute">The execution logic.</param>
+    /// <param name="canExecute">The execution status logic.</param>
+    public RelayCommand(Action<object> execute, Predicate<object?>? canExecute = null)
+    {
+        _execute = execute;
+        _canExecute = canExecute;
+    }
+
+    public bool CanExecute(object? parameter)
+    {
+        return _canExecute?.Invoke(parameter) ?? true;
+    }
+
+    public void Execute(object? parameter)
+    {
+        // For now, we are ignoring the warning about the parameter being null.
+        _execute(parameter!);
+    }
+
+    public event EventHandler? CanExecuteChanged
+    {
+        add => CommandManager.RequerySuggested += value;
+        remove => CommandManager.RequerySuggested -= value;
+    }
+
+    public void RaiseCanExecuteChanged()
+    {
+        CommandManager.InvalidateRequerySuggested();
+    }
+}
diff --git a/ActiveDirectoryQuerier/TextBoxViewModel.cs b/ActiveDirectoryQuerier/ViewModels/TextBoxViewModel.cs
similarity index 50%
rename from ActiveDirectoryQuerier/TextBoxViewModel.cs
rename to ActiveDirectoryQuerier/ViewModels/TextBoxViewModel.cs
index 063b48b..b81e606 100644
--- a/ActiveDirectoryQuerier/TextBoxViewModel.cs
+++ b/ActiveDirectoryQuerier/ViewModels/TextBoxViewModel.cs
@@ -1,20 +1,18 @@
 using System.ComponentModel;
 
-namespace ActiveDirectoryQuerier;
+namespace ActiveDirectoryQuerier.ViewModels;
 
 /// <summary>
-/// ViewModel for a ComboBox that displays possible parameters for a PowerShell command.
-/// It is used when adding a new parameter slot to a command in the UI.
+/// ViewModel for a TextBox that contains the value of a parameter slot.
+/// It is used to bind the TextBox to the ViewModel.
 /// </summary>
+/// TODO: Place class into ViewModel folder.
 public sealed class TextBoxViewModel : INotifyPropertyChanged
 {
     public event PropertyChangedEventHandler? PropertyChanged;
-    private string _selectedParameterValue = string.Empty;
+    private string? _selectedParameterValue;
 
-    /// <summary>
-    /// Gets or sets the selected parameter value for the unique ComboBox.
-    /// </summary>
-    public string SelectedParameterValue
+    public string? SelectedParameterValue
     {
         get => _selectedParameterValue;
         set {
@@ -26,10 +24,6 @@ public string SelectedParameterValue
         }
     }
 
-    /// <summary>
-    /// Invokes the PropertyChanged event for the specified property name.
-    /// </summary>
-    /// <param name="propertyName">Name of the property that has changed.</param>
     private void OnPropertyChanged(string propertyName)
     {
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
diff --git a/README.md b/README.md
index 45001ef..1dd1f42 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,11 @@
 [![Project Tracker](https://img.shields.io/badge/repo%20status-Project%20Tracker-lightgrey)](https://wiki.hthompson.dev/en/project-tracker)
 ![Platform](https://img.shields.io/badge/platform-Windows-lightgrey)
 [![Style Guide](https://img.shields.io/badge/code%20style-Style%20Guide-blueviolet)](https://gist.github.com/StrangeRanger/f7f87dd884760f3127adda98d3d4ab14)
+
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/StrangeRanger/FAFB-PowerShell-Tool/build-test-ci.yml)
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/ce2ddca07a934a5f85e8061e295f3324)](https://app.codacy.com/gh/StrangeRanger/FAFB-PowerShell-Tool/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+![Static Badge](https://img.shields.io/badge/state-Beta-orange)
+![GitHub release (latest by date)](https://img.shields.io/github/v/release/StrangeRanger/FAFB-PowerShell-Tool)
 
 Active Directory Querier is a Windows GUI for creating, saving, and executing one or more PowerShell commands, against a Local Active Directory.
 
@@ -11,12 +15,4 @@ Active Directory Querier is a Windows GUI for creating, saving, and executing on
 
 ### Installing
 
-Active Directory Querier does not require to be installed. Simply go to [the lastest releases tab](https://github.com/StrangeRanger/FAFB-PowerShell-Tool/releases), and download the version for your appropriate architecture...
-
-## Usage
-
-...
-
-## Supported Operating Systems
-
-...
+Active Directory Querier does not require the installation of any software. Simply go to [the lastest releases tab](https://github.com/StrangeRanger/FAFB-PowerShell-Tool/releases), and download the version for your appropriate architecture.