diff --git a/src/qest/Commands/GenerateCommand.cs b/src/qest/Commands/GenerateCommand.cs
index 442bf0d..74be141 100644
--- a/src/qest/Commands/GenerateCommand.cs
+++ b/src/qest/Commands/GenerateCommand.cs
@@ -113,7 +113,6 @@ public override async Task<int> ExecuteAsync([NotNull] CommandContext context, [
                 }
 
                 await Utils.SafeWriteYamlAsync(folder!, currentTest);
-
             }
             catch (Exception ex)
             {
diff --git a/src/qest/Commands/RunCommand.cs b/src/qest/Commands/RunCommand.cs
index d669ea6..afe6a92 100644
--- a/src/qest/Commands/RunCommand.cs
+++ b/src/qest/Commands/RunCommand.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data.SqlClient;
 using System.Diagnostics.CodeAnalysis;
@@ -7,6 +6,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using qest.Models;
+using qest.Runners;
 using Spectre.Console;
 using Spectre.Console.Cli;
 namespace qest.Commands
@@ -86,24 +86,33 @@ public override async Task<int> ExecuteAsync([NotNull] CommandContext context, [
                     TestCollection.AddRange(await Utils.SafeReadYamlAsync(item));
             }
 
-            AnsiConsole.MarkupLine($"[grey]{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}[/] {TestCollection.Count} tests loaded.");
+            var root = new Tree($"{TestCollection.Count} tests loaded");
 
             TargetSqlConnection = new SqlConnection(settings.ConnectionString);
 
             int exitCode = 0;
 
-            foreach (var test in TestCollection)
-            {
+            await AnsiConsole.Live(root)
+                .StartAsync(async ctx => 
+                {
+                    foreach (var test in TestCollection)
+                    {
+                        var testNode = root.AddNode($"{test.Name}".EscapeAndAddStyles("bold,blue"));
 
-                test.Connection = TargetSqlConnection;
-                bool pass = await test.RunAsync();
+                        var runner = new TreeRunner(test, TargetSqlConnection, testNode);
+                        ctx.Refresh();
+
+                        bool pass = await runner.RunAsync();
+                        ctx.Refresh();
+
+                        if (!pass)
+                        {
+                            exitCode = 1;
+                            break;
+                        }
+                    }
+                });
 
-                if (!pass)
-                {
-                    exitCode = 1;
-                    break;
-                }
-            }
 
             return exitCode;
         }
diff --git a/src/qest/Models/Script.cs b/src/qest/Models/Script.cs
index 011855e..4792169 100644
--- a/src/qest/Models/Script.cs
+++ b/src/qest/Models/Script.cs
@@ -44,4 +44,9 @@ public enum ScriptType
         Inline,
         File
     }
+
+    public class Scripts : List<Script>
+    {
+        
+    }
 }
diff --git a/src/qest/Models/Scripts.cs b/src/qest/Models/Scripts.cs
deleted file mode 100644
index 1a3ed14..0000000
--- a/src/qest/Models/Scripts.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using System.Collections.Generic;
-using System.Data.SqlClient;
-using System.Threading.Tasks;
-
-namespace qest.Models
-{
-    public class Scripts : List<Script>
-    {
-        public async Task RunAsync(Test parentTest, string scopeName)
-        {
-            var transaction = parentTest.Connection!.BeginTransaction();
-            parentTest.Logger($"Running {scopeName} scripts...", null);
-            try
-            {
-                foreach (var item in this)
-                {
-                    string script = item.Compact(parentTest.Variables);
-                    if (script.Length > 0)
-                    {
-                        var cmd = new SqlCommand(script, parentTest.Connection, transaction);
-                        await cmd.ExecuteNonQueryAsync();
-                    }
-                }
-                await transaction.CommitAsync();
-            }
-            catch
-            {
-                await transaction.RollbackAsync();
-                throw;
-            }
-            parentTest.Logger("Completed.", false);            
-        }
-    }
-
-}
diff --git a/src/qest/Models/Test.cs b/src/qest/Models/Test.cs
index e83c8f6..4de8c25 100644
--- a/src/qest/Models/Test.cs
+++ b/src/qest/Models/Test.cs
@@ -1,11 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Data.SqlClient;
-using System.Linq;
-using System.Threading.Tasks;
-using Spectre.Console;
-using YamlDotNet.Serialization;
+using System.Collections.Generic;
 
 namespace qest.Models
 {
@@ -13,249 +6,8 @@ public class Test
     {
         public string Name { get; set; }
         public Scripts? Before { get; set; }
-        [YamlIgnore]
-        public SqlConnection? Connection { get; set; }
         public List<TestStep> Steps { get; set; }
         public Scripts? After { get; set; }
         public Dictionary<string, object>? Variables { get; set; }
-        [YamlIgnore]
-        private bool Pass;
-
-        public async Task<bool> RunAsync()
-        {
-            Logger($"Running Test: {this.Name}", customStyle: "bold,blue");
-            Pass = true;
-
-            if (Connection == null)
-            {
-                Logger($"FATAL: SQL Connection null", true, "bold");
-                return false;
-            }
-
-            if (Steps == null)
-            {
-                Logger($"FATAL: TestCases null", true, "bold");
-                return false;
-            }
-
-            try
-            {
-                await Connection.OpenAsync();
-
-                await Before?.RunAsync(this, "Before");
-
-                foreach (var testCase in Steps)
-                {
-                    RunTestStep(this, testCase);
-                }
-            }
-            catch (Exception ex)
-            {
-                Logger($"FATAL: {ex}", true);
-            }
-            finally
-            {
-                await After?.RunAsync(this, "After");
-                await Connection.CloseAsync();
-            }
-
-            Logger($"Test {Name}: {(Pass ? "OK" : "KO")}", !Pass, "bold");
-
-            return Pass;
-        }
-
-        private void RunTestStep(Test parentTest, TestStep step)
-        {
-            Logger($"Running Test {parentTest.Name} - Step: {step.Name}", customStyle: "blue");
-            SqlCommand testCmd = new(step.Command.CommandText, Connection);
-            testCmd.CommandType = CommandType.StoredProcedure;
-
-            // add input pars
-            if (step.Command.Parameters != null)
-                foreach (var input in step.Command.Parameters)
-                {
-                    testCmd.Parameters.AddWithValue($"@{input.Key}", input.Value?.ReplaceVarsInParameter(Variables));
-                }
-
-            // add output pars
-            List<SqlParameter> outPars = new();
-            if (step.Results != null)
-            {
-                if (step.Results.OutputParameters != null)
-                    foreach (var output in step.Results.OutputParameters)
-                    {
-                        var outPar = testCmd.Parameters.Add($"@{output.Name}", output.Type);
-                        outPar.Direction = ParameterDirection.Output;
-                        outPars.Add(outPar);
-                    }
-
-                // add rc if exists
-                if (step.Results.ReturnCode.HasValue)
-                {
-                    var rc = step.Results.ReturnCode;
-                    var outPar = testCmd.Parameters.Add($"@rc", SqlDbType.Int);
-                    outPar.Direction = ParameterDirection.ReturnValue;
-                    outPars.Add(outPar);
-                }
-            }
-
-            using var reader = testCmd.ExecuteReader();
-
-            if (step.Results != null)
-            {
-                // resultsets
-                if (step.Results.ResultSets != null)
-                {
-                    var resultSets = step.Results.ResultSets;
-
-                    List<DataTable> dataTables = new();
-
-                    foreach (var resultSet in resultSets)
-                    {
-                        Logger($"Loading ResultSet: {resultSet.Name}");
-                        DataTable dataTable = resultSet.GetDataTable();
-
-                        while (reader.Read())
-                        {
-                            DataRow row = dataTable.NewRow();
-
-                            for (int f = 0; f < resultSet.Columns.Count; f++)
-                            {
-                                var column = resultSet.Columns[f];
-
-                                if (reader.IsDBNull(f))
-                                    row[column.Name] = DBNull.Value;
-                                else
-                                    row[column.Name] = Convert.ChangeType(reader.GetValue(f), Utils.MapType(column.Type));
-                            }
-                            dataTable.Rows.Add(row);
-                        }
-
-                        dataTables.Add(dataTable);
-                        reader.NextResult();
-                    }
-
-                    foreach (var expected in step.Results.ResultSets)
-                    {
-                        Logger($"Checking ResultSet: {expected.Name}");
-                        var currRes = dataTables.Where(d => d.TableName == expected.Name).FirstOrDefault();
-
-                        if (currRes == null)
-                        {
-                            Logger($"Resultset {expected.Name} not found", true);
-                            continue;
-                        }
-
-                        if (expected.RowNumber != null)
-                        {
-                            if (expected.RowNumber != currRes.Rows.Count)
-                            {
-                                Logger($"ResultSet {expected.Name} row number: {currRes.Rows.Count} != {expected.RowNumber}", true);
-                                continue;
-                            }
-                        }
-
-                        Logger($"Result {expected.Name}: OK", false);
-                    }
-                }
-
-                reader.Close();
-
-                //output parameters
-                if (step.Results.OutputParameters != null)
-                {
-                    foreach (var expected in step.Results.OutputParameters)
-                    {
-                        Logger($"Checking Output Parameter: {expected.Name}");
-                        var currRes = outPars.Where(p => p.ParameterName == $"@{expected.Name}").FirstOrDefault();
-                        if (currRes == null)
-                        {
-                            Logger($"Output Parameter {expected.Name} not found", true);
-                            continue;
-                        }
-
-                        if (expected.Value != null)
-                        {
-                            if (!currRes.Value.Equals(currRes.Value))
-                            {
-                                Logger($"Ouput Parameter {expected.Name}: {currRes.Value} != {expected.Value}", true);
-                                continue;
-                            }
-                        }
-
-                        Logger($"Result {expected.Name}: {expected.Value} == {currRes.Value}", false);
-                    }
-                }
-
-                //returncode
-                if (step.Results.ReturnCode.HasValue)
-                {
-                    var expected = step.Results.ReturnCode.Value;
-                    Logger($"Checking Return Code");
-                    var rcPar = outPars.Where(p => p.ParameterName == $"@rc").FirstOrDefault();
-                    if (rcPar == null)
-                    {
-                        Logger($"Return Code not found", true);
-                    }
-                    else
-                    {
-                        if (expected != Convert.ToInt32(rcPar.Value))
-                            Logger($"Return Code: {rcPar.Value} != {expected}", true);
-                        else
-                            Logger($"Return Code: {expected} == {expected}", false);
-                    }
-                }
-            }
-
-            // asserts
-            if (step.Asserts != null)
-            {
-                Logger($"Checking Asserts");
-                foreach (var assert in step.Asserts)
-                {
-                    var assertSqlQuery = assert.SqlQuery.ReplaceVars(Variables);
-                    var assertScalarValue = assert.ScalarValue.ReplaceVarsInParameter(Variables);
-                    SqlCommand cmd = new(assertSqlQuery, Connection);
-                    var result = cmd.ExecuteScalar();
-                    if (result != null)
-                    {
-                        bool pass = false;
-                        var scalarType = Utils.MapType(assert.ScalarType);
-                        pass = Convert.ChangeType(assertScalarValue, scalarType).Equals(Convert.ChangeType(result, scalarType));
-
-                        if (pass)
-                            Logger($"{assertSqlQuery}: {result} == {assertScalarValue}", false);
-                        else
-                            Logger($"{assertSqlQuery}: {result} != {assertScalarValue}", true);
-                    }
-                    else
-                        Logger($"{assertSqlQuery}: Result NULL", true);
-                }
-            }
-        }
-
-        internal void Logger(string message, bool? isError = null, string? customStyle = null)
-        {
-            string pfx = $"[grey]{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}[/]";
-
-            message = message.EscapeMarkup();
-
-            if (customStyle is not null)
-                foreach (string style in customStyle.Split(','))
-                    message = $"[{style}]{message}[/]";
-
-            if (isError.HasValue)
-            {
-                Pass = (Pass && !isError.Value);
-                if (isError.Value)
-                    message = $"{pfx} [red]{message}[/]";
-                else
-                    message = $"{pfx} [green]{message}[/]";
-            }
-            else
-                message = $"{pfx} {message}";
-
-            AnsiConsole.MarkupLine(message);
-        }
     }
 }
diff --git a/src/qest/Runners/TreeRunner.cs b/src/qest/Runners/TreeRunner.cs
new file mode 100644
index 0000000..6299d4e
--- /dev/null
+++ b/src/qest/Runners/TreeRunner.cs
@@ -0,0 +1,299 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Threading.Tasks;
+using qest.Models;
+using Spectre.Console;
+
+namespace qest.Runners
+{
+    public class TreeRunner
+    {
+        private readonly Test Test;
+        private readonly SqlConnection Connection;
+        private readonly TreeNode Node;
+        private bool Pass;
+
+        private const string objectStyle = "blue";
+        private const string errorStyle = "bold red";
+        private const string okStyle = "green";
+
+        public TreeRunner(Test _test, SqlConnection _connection, TreeNode _node)
+        {
+            Test = _test;
+            Connection = _connection;
+            Node = _node;
+            Pass = true;
+        }
+
+        public async Task<bool> RunAsync()
+        {
+            Pass = true;
+
+            if (Test.Steps == null)
+            {
+                Node.AddNode("FATAL: TestCases null".EscapeAndAddStyles(errorStyle));
+                return false;
+            }
+
+            try
+            {
+                await Connection.OpenAsync();
+
+                if (Test.Before is not null)
+                {
+                    string objName = "Before".EscapeAndAddStyles(objectStyle);
+                    var beforeNode = Node.AddNode($"Scripts: {objName}");
+                    await RunScriptAsync(Test.Before);
+                    beforeNode.AddNode("OK".EscapeAndAddStyles(okStyle));
+                }
+
+                foreach (var testCase in Test.Steps)
+                {
+                    var testCaseNode = Node.AddNode($"Step: {testCase.Name.EscapeAndAddStyles(objectStyle)}");
+                    RunTestStep(testCase, Test.Variables, testCaseNode);
+                }
+            }
+            catch (Exception ex)
+            {
+               Node.AddNode($"FATAL: {ex}".EscapeAndAddStyles(errorStyle));
+            }
+            finally
+            {
+                if (Test.After is not null)
+                {
+                    string objName = "After".EscapeAndAddStyles(objectStyle);
+                    var afterNode = Node.AddNode($"Scripts: {objName}");
+                    await RunScriptAsync(Test.After);
+                    afterNode.AddNode("OK".EscapeAndAddStyles(okStyle));
+                }
+
+                await Connection.CloseAsync();
+            }
+
+            if (Pass)
+                Node.AddNode($"{Test.Name}: OK".EscapeAndAddStyles($"bold {okStyle}"));
+            else
+                Node.AddNode($"{Test.Name}: KO!".EscapeAndAddStyles(errorStyle));
+
+            return Pass;
+        }
+
+        private void RunTestStep(TestStep step, Dictionary<string, object>? variables, TreeNode testCaseNode)
+        {
+            SqlCommand testCmd = new(step.Command.CommandText, Connection);
+            testCmd.CommandType = CommandType.StoredProcedure;
+
+            // add input pars
+            if (step.Command.Parameters != null)
+                foreach (var input in step.Command.Parameters)
+                {
+                    testCmd.Parameters.AddWithValue($"@{input.Key}", input.Value?.ReplaceVarsInParameter(variables));
+                }
+
+            // add output pars
+            List<SqlParameter> outPars = new();
+            if (step.Results != null)
+            {
+                if (step.Results.OutputParameters != null)
+                    foreach (var output in step.Results.OutputParameters)
+                    {
+                        var outPar = testCmd.Parameters.Add($"@{output.Name}", output.Type);
+                        outPar.Direction = ParameterDirection.Output;
+                        outPars.Add(outPar);
+                    }
+
+                // add rc if exists
+                if (step.Results.ReturnCode.HasValue)
+                {
+                    var rc = step.Results.ReturnCode;
+                    var outPar = testCmd.Parameters.Add($"@rc", SqlDbType.Int);
+                    outPar.Direction = ParameterDirection.ReturnValue;
+                    outPars.Add(outPar);
+                }
+            }
+
+            using var reader = testCmd.ExecuteReader();
+
+            if (step.Results != null)
+            {
+                // resultsets
+                if (step.Results.ResultSets != null)
+                {
+                    var resultSets = step.Results.ResultSets;
+                    var resultSetsNode = testCaseNode.AddNode("Result Sets");
+
+                    List<DataTable> dataTables = new();
+                    Dictionary<string, TreeNode> dataSetNodes = new();
+
+                    foreach (var resultSet in resultSets)
+                    {
+                        var rs_node = resultSetsNode.AddNode($"{resultSet.Name}".EscapeAndAddStyles(objectStyle));
+                        DataTable dataTable = resultSet.GetDataTable();
+
+                        while (reader.Read())
+                        {
+                            DataRow row = dataTable.NewRow();
+
+                            for (int f = 0; f < resultSet.Columns.Count; f++)
+                            {
+                                var column = resultSet.Columns[f];
+
+                                if (reader.IsDBNull(f))
+                                    row[column.Name] = DBNull.Value;
+                                else
+                                    row[column.Name] = Convert.ChangeType(reader.GetValue(f), Utils.MapType(column.Type));
+                            }
+                            dataTable.Rows.Add(row);
+                        }
+
+                        dataTables.Add(dataTable);
+                        dataSetNodes.Add(resultSet.Name, rs_node);
+                        reader.NextResult();
+                    }
+
+                    foreach (var expected in step.Results.ResultSets)
+                    {
+                        var currRes = dataTables.Where(d => d.TableName == expected.Name).FirstOrDefault();
+                        var currNode = dataSetNodes[expected.Name];
+
+                        if (currRes == null)
+                        {
+                            currNode.AddNode($"Not found!".EscapeAndAddStyles(errorStyle));
+                            Pass = false;
+                            continue;
+                        }
+
+                        if (expected.RowNumber != null)
+                        {
+                            if (expected.RowNumber != currRes.Rows.Count)
+                            {
+                                currNode.AddNode($"Row number: {currRes.Rows.Count} != {expected.RowNumber}".EscapeAndAddStyles(errorStyle));
+                                Pass = false;
+                                continue;
+                            }
+                        }
+                        
+                        currNode.AddNode($"OK".EscapeAndAddStyles(okStyle));
+                    }
+                }
+
+                reader.Close();
+
+                //output parameters
+                if (step.Results.OutputParameters != null)
+                {
+                    var outputParsNode = testCaseNode.AddNode("Output Parameters");
+                    foreach (var expected in step.Results.OutputParameters)
+                    {
+                        var currRes = outPars.Where(p => p.ParameterName == $"@{expected.Name}").FirstOrDefault();
+                        var currNode = outputParsNode.AddNode($"{expected.Name}".EscapeAndAddStyles(objectStyle));
+
+                        if (currRes == null)
+                        {
+                            currNode.AddNode("Not found!".EscapeAndAddStyles(errorStyle));
+                            Pass = false;
+                            continue;
+                        }
+
+                        if (expected.Value != null)
+                        {
+                            if (!currRes.Value.Equals(currRes.Value))
+                            {
+                                currNode.AddNode($"{currRes.Value} != {expected.Value}".EscapeAndAddStyles(errorStyle));
+                                Pass = false;
+                                continue;
+                            }
+                        }
+
+                        currNode.AddNode($"{expected.Value} == {currRes.Value}".EscapeAndAddStyles(okStyle));
+                    }
+                }
+
+                //returncode
+                if (step.Results.ReturnCode.HasValue)
+                {
+                    var rcNode = testCaseNode.AddNode("[blue]Return Code[/]");
+                    var expected = step.Results.ReturnCode.Value;
+                    var rcPar = outPars.Where(p => p.ParameterName == $"@rc").FirstOrDefault();
+                    if (rcPar == null)
+                    {
+                        rcNode.AddNode("Not found!".EscapeAndAddStyles(errorStyle));
+                        Pass = false;
+                    }
+                    else
+                    {
+                        if (expected != Convert.ToInt32(rcPar.Value))
+                        {
+                            rcNode.AddNode($"{rcPar.Value} != {expected}".EscapeAndAddStyles(errorStyle));
+                            Pass = false;
+                        }
+                        else
+                            rcNode.AddNode($"{expected} == {expected}".EscapeAndAddStyles(okStyle));
+                    }
+                }
+            }
+
+            // asserts
+            if (step.Asserts != null)
+            {
+                var assertsNode = testCaseNode.AddNode("Asserts");
+                foreach (var assert in step.Asserts)
+                {
+                    var assertSqlQuery = assert.SqlQuery.ReplaceVars(Test.Variables);                    
+                    var assertScalarValue = assert.ScalarValue.ReplaceVarsInParameter(Test.Variables);
+
+                    var currNode = assertsNode.AddNode(assertSqlQuery.EscapeAndAddStyles(objectStyle));
+
+                    SqlCommand cmd = new(assertSqlQuery, Connection);
+                    var result = cmd.ExecuteScalar();
+                    if (result is null)
+                    {
+                        currNode.AddNode($"NULL != {assertScalarValue}".EscapeAndAddStyles(errorStyle));
+                        Pass = false;
+                    }
+                    else
+                    {
+                        bool convertOk = false;
+                        var scalarType = Utils.MapType(assert.ScalarType);
+                        convertOk = Convert.ChangeType(assertScalarValue, scalarType).Equals(Convert.ChangeType(result, scalarType));
+
+                        if (convertOk)
+                            currNode.AddNode($"{result} == {assertScalarValue}".EscapeAndAddStyles(okStyle));
+                        else
+                        {
+                            currNode.AddNode($"{result} != {assertScalarValue}".EscapeAndAddStyles(errorStyle));
+                            Pass = false;
+                        }
+                    }
+                }
+            }
+        }
+
+
+        private async Task RunScriptAsync(List<Script> scripts)
+        {
+            var transaction = Connection.BeginTransaction();
+            try
+            {
+                foreach (var item in scripts)
+                {
+                    string script = item.Compact(Test.Variables);
+                    if (script.Length > 0)
+                    {
+                        var cmd = new SqlCommand(script, Connection, transaction);
+                        await cmd.ExecuteNonQueryAsync();
+                    }
+                }
+                await transaction.CommitAsync();
+            }
+            catch
+            {
+                await transaction.RollbackAsync();
+                throw;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/qest/Utils/ExtensionMethods.cs b/src/qest/Utils/ExtensionMethods.cs
new file mode 100644
index 0000000..be10904
--- /dev/null
+++ b/src/qest/Utils/ExtensionMethods.cs
@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Linq;
+using Spectre.Console;
+
+namespace qest
+{
+    internal static partial class Utils
+    {
+        internal static object? ReplaceVarsInParameter(this object value, Dictionary<string, object>? variables)
+        {
+            if (variables != null && value is string stringValue)
+            {
+                var result = stringValue.ReplaceVars(variables);
+                return result != "NULL" ? result : null;
+            }
+            else
+            {
+                return value;
+            }
+        }
+
+        internal static string ReplaceVars(this string value, Dictionary<string, object>? variables)
+        {
+            if (variables != null)
+            {
+                return variables.Aggregate(value, (acc, var) => acc.Replace($"{{{var.Key}}}", var.Value?.ToString() ?? "NULL"));
+            }
+            else
+            {
+                return value;
+            }
+        }
+
+        internal static string EscapeAndAddStyles(this string message, string? customStyle)
+        {
+            message = message.EscapeMarkup();
+
+            if (customStyle is not null)
+                foreach (string style in customStyle.Split(','))
+                    message = $"[{style}]{message}[/]";
+
+            return message;
+        }
+    }
+}
diff --git a/src/qest/Utils/IO.cs b/src/qest/Utils/IO.cs
new file mode 100644
index 0000000..3499d9a
--- /dev/null
+++ b/src/qest/Utils/IO.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using qest.Models;
+using Spectre.Console;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace qest
+{
+    internal static partial class Utils
+    {
+        internal static List<Test> SafeReadYaml(FileInfo file) => SafeReadYamlAsync(file).GetAwaiter().GetResult();
+        internal static async Task<List<Test>> SafeReadYamlAsync(FileInfo file)
+        {
+            List<Test> list = new List<Test>();
+
+            var deserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .Build();
+
+            try
+            {
+                using var stream = new StreamReader(file.FullName);
+                string yaml = await stream.ReadToEndAsync();
+                list.AddRange(deserializer.Deserialize<List<Test>>(yaml));
+            }
+            catch (Exception ex)
+            {
+                AnsiConsole.MarkupLineInterpolated($"[bold red]Error deserializing {file.FullName}[/]");
+                AnsiConsole.WriteException(ex);
+            }
+            return list;
+        }
+
+        internal static async Task SafeWriteYamlAsync(DirectoryInfo folder, Test testTemplate)
+        {
+            FileInfo output = new(Path.Combine(folder.Name, $"{testTemplate.Name}.yml"));
+
+            var serializer = new SerializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .Build();
+
+            try
+            {
+                await using var stream = new StreamWriter(output.FullName, false);
+
+                string yaml = serializer.Serialize(new Test[] { testTemplate });
+                await stream.WriteLineAsync(yamlSchema);
+                await stream.WriteAsync(yaml);
+                AnsiConsole.MarkupLine($"Created Template: {folder.Name}/{testTemplate.Name.EscapeAndAddStyles("blue")}");
+            }
+            catch (Exception ex)
+            {
+                AnsiConsole.MarkupLineInterpolated($"[bold red]Error serializing {output.FullName}[/]");
+                AnsiConsole.WriteException(ex);
+            }
+        }
+    }
+}
diff --git a/src/qest/Utils/Maps.cs b/src/qest/Utils/Maps.cs
new file mode 100644
index 0000000..a3e5ce6
--- /dev/null
+++ b/src/qest/Utils/Maps.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Data;
+
+namespace qest
+{
+    internal static partial class Utils
+    {
+        internal static Type MapType(SqlDbType type) => type switch
+        {
+            SqlDbType.Bit => typeof(bool),
+            SqlDbType.TinyInt => typeof(byte),
+            SqlDbType.SmallInt => typeof(short),
+            SqlDbType.BigInt => typeof(long),
+            SqlDbType.Float => typeof(double),
+            SqlDbType.Int => typeof(int),
+            SqlDbType.NVarChar => typeof(string),
+            SqlDbType.DateTime => typeof(DateTime),
+            SqlDbType.DateTime2 => typeof(DateTime),
+            SqlDbType.Date => typeof(DateTime),
+            SqlDbType.DateTimeOffset => typeof(DateTimeOffset),
+            SqlDbType.Time => typeof(TimeSpan),
+            SqlDbType.Real => typeof(float),
+            SqlDbType.Decimal => typeof(decimal),
+            SqlDbType.Money => typeof(decimal),
+
+            _ => throw new ArgumentOutOfRangeException(nameof(type), $"Type not expected: {type}"),
+        };
+
+        internal static SqlDbType MapSqlType(string type) => type switch
+        {
+            "bit" => SqlDbType.Bit,
+            "tinyint" => SqlDbType.TinyInt,
+            "smallint" => SqlDbType.SmallInt,
+            "bigint" => SqlDbType.BigInt,
+            "float" => SqlDbType.Float,
+            "int" => SqlDbType.Int,
+            "nvarchar" => SqlDbType.NVarChar,
+            "datetime" => SqlDbType.DateTime,
+            "datetime2" => SqlDbType.DateTime2,
+            "date" => SqlDbType.Date,
+            "datetimetoffset" => SqlDbType.DateTimeOffset,
+            "time" => SqlDbType.Time,
+            "real" => SqlDbType.Real,
+            "decimal" => SqlDbType.Decimal,
+            "money" => SqlDbType.Decimal,
+
+            _ => throw new ArgumentOutOfRangeException(nameof(type), $"Type not expected: {type}"),
+        };
+    }
+}
diff --git a/src/qest/Utils/Strings.cs b/src/qest/Utils/Strings.cs
new file mode 100644
index 0000000..feef30e
--- /dev/null
+++ b/src/qest/Utils/Strings.cs
@@ -0,0 +1,10 @@
+namespace qest
+{
+    internal static partial class Utils
+    {
+        internal const string ConnectionStringBarebone = "Server=;Initial Catalog=;User=;Password=;";
+
+        internal const string yamlSchema = 
+            @"# yaml-language-server: $schema=https://raw.githubusercontent.com/Geims83/qest/0.9.2/docs/yamlSchema.json";
+    }
+}
diff --git a/src/qest/Utils/Utils.cs b/src/qest/Utils/Utils.cs
deleted file mode 100644
index 26d1d58..0000000
--- a/src/qest/Utils/Utils.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using qest.Models;
-using YamlDotNet.Serialization;
-using YamlDotNet.Serialization.NamingConventions;
-
-namespace qest
-{
-    internal static class Utils
-    {
-        internal static Type MapType(SqlDbType type) => type switch
-        {
-            SqlDbType.Bit => typeof(bool),
-            SqlDbType.TinyInt => typeof(byte),
-            SqlDbType.SmallInt => typeof(short),
-            SqlDbType.BigInt => typeof(long),
-            SqlDbType.Float => typeof(double),
-            SqlDbType.Int => typeof(int),
-            SqlDbType.NVarChar => typeof(string),
-            SqlDbType.DateTime => typeof(DateTime),
-            SqlDbType.DateTime2 => typeof(DateTime),
-            SqlDbType.Date => typeof(DateTime),
-            SqlDbType.DateTimeOffset => typeof(DateTimeOffset),
-            SqlDbType.Time => typeof(TimeSpan),
-            SqlDbType.Real => typeof(float),
-            SqlDbType.Decimal => typeof(decimal),
-            SqlDbType.Money => typeof(decimal),
-
-            _ => throw new ArgumentOutOfRangeException(nameof(type), $"Type not expected: {type}"),
-        };
-
-        internal static SqlDbType MapSqlType(string type) => type switch
-        {
-            "bit" => SqlDbType.Bit,
-            "tinyint" => SqlDbType.TinyInt,
-            "smallint" => SqlDbType.SmallInt,
-            "bigint" => SqlDbType.BigInt,
-            "float" => SqlDbType.Float,
-            "int" => SqlDbType.Int,
-            "nvarchar" => SqlDbType.NVarChar,
-            "datetime" => SqlDbType.DateTime,
-            "datetime2" => SqlDbType.DateTime2,
-            "date" => SqlDbType.Date,
-            "datetimetoffset" => SqlDbType.DateTimeOffset,
-            "time" => SqlDbType.Time,
-            "real" => SqlDbType.Real,
-            "decimal" => SqlDbType.Decimal,
-            "money" => SqlDbType.Decimal,
-
-            _ => throw new ArgumentOutOfRangeException(nameof(type), $"Type not expected: {type}"),
-        };
-        internal static object? ReplaceVarsInParameter(this object value, Dictionary<string, object>? variables)
-        {
-            if (variables != null && value is string stringValue)
-            {
-                var result = stringValue.ReplaceVars(variables);
-                return result != "NULL" ? result : null;
-            }
-            else
-            {
-                return value;
-            }
-        }
-
-        internal static string ReplaceVars(this string value, Dictionary<string, object>? variables)
-        {
-            if (variables != null)
-            {
-                return variables.Aggregate(value, (acc, var) => acc.Replace($"{{{var.Key}}}", var.Value?.ToString() ?? "NULL"));
-            }
-            else
-            {
-                return value;
-            }
-        }
-
-        internal static List<Test> SafeReadYaml(FileInfo file)
-        {
-            List<Test> list = new List<Test>();
-
-            var deserializer = new DeserializerBuilder()
-                .WithNamingConvention(CamelCaseNamingConvention.Instance)
-                .Build();
-
-            try
-            {
-                using var stream = new StreamReader(file.FullName);
-                string yaml = stream.ReadToEnd();
-                list.AddRange(deserializer.Deserialize<List<Test>>(yaml));
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Error deserializing {file.FullName}: {ex.Message}");
-            }
-            return list;
-        }
-
-        internal static async Task<List<Test>> SafeReadYamlAsync(FileInfo file)
-        {
-            List<Test> list = new List<Test>();
-
-            var deserializer = new DeserializerBuilder()
-                .WithNamingConvention(CamelCaseNamingConvention.Instance)
-                .Build();
-
-            try
-            {
-                using var stream = new StreamReader(file.FullName);
-                string yaml = await stream.ReadToEndAsync();
-                list.AddRange(deserializer.Deserialize<List<Test>>(yaml));
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Error deserializing {file.FullName}: {ex.Message}");
-            }
-            return list;
-        }
-        
-        internal const string ConnectionStringBarebone = "Server=;Initial Catalog=;User=;Password=;";
-
-        internal const string yamlSchema = 
-            @"# yaml-language-server: $schema=https://raw.githubusercontent.com/Geims83/qest/0.9.2/docs/yamlSchema.json";
-        
-        internal static async Task SafeWriteYamlAsync(DirectoryInfo folder, Test testTemplate)
-        {
-            FileInfo output = new(Path.Combine(folder.Name, $"{testTemplate.Name}.yml"));
-
-            var serializer = new SerializerBuilder()
-                .WithNamingConvention(CamelCaseNamingConvention.Instance)
-                .Build();
-
-            try
-            {
-                await using var stream = new StreamWriter(output.FullName, false);
-
-                string yaml = serializer.Serialize(new Test[] {testTemplate});
-                await stream.WriteLineAsync(yamlSchema);
-                await stream.WriteAsync(yaml);
-                
-                Console.WriteLine($"Created template {output.Name}");
-            }
-            catch (Exception ex)
-            {
-                Console.ForegroundColor = ConsoleColor.Red;
-                Console.WriteLine($"Error creating template {output.Name}: {ex.Message}");
-                Console.ResetColor();
-            }
-        }
-    }
-}