diff --git a/src/OrchardCore.Modules/OrchardCore.AutoSetup/AutoSetupMiddleware.cs b/src/OrchardCore.Modules/OrchardCore.AutoSetup/AutoSetupMiddleware.cs
index 77c895a57fe..e535df16879 100644
--- a/src/OrchardCore.Modules/OrchardCore.AutoSetup/AutoSetupMiddleware.cs
+++ b/src/OrchardCore.Modules/OrchardCore.AutoSetup/AutoSetupMiddleware.cs
@@ -214,7 +214,7 @@ public async Task<ShellSettings> CreateTenantSettingsAsync(TenantSetupOptions se
 
             shellSettings["ConnectionString"] = setupOptions.DatabaseConnectionString;
             shellSettings["TablePrefix"] = setupOptions.DatabaseTablePrefix;
-            shellSettings["DatabaseProvider"] = setupOptions.DatabaseProvider;
+            shellSettings["DatabaseProvider"] = setupOptions.DatabaseProvider.ToString();
             shellSettings["Secret"] = Guid.NewGuid().ToString();
             shellSettings["RecipeName"] = setupOptions.RecipeName;
 
diff --git a/src/OrchardCore.Modules/OrchardCore.AutoSetup/Options/TenantSetupOptions.cs b/src/OrchardCore.Modules/OrchardCore.AutoSetup/Options/TenantSetupOptions.cs
index 23e2cfa9793..10b53b7897b 100644
--- a/src/OrchardCore.Modules/OrchardCore.AutoSetup/Options/TenantSetupOptions.cs
+++ b/src/OrchardCore.Modules/OrchardCore.AutoSetup/Options/TenantSetupOptions.cs
@@ -43,7 +43,7 @@ public class TenantSetupOptions
         /// <summary>
         /// Gets or sets the database provider.
         /// </summary>
-        public string DatabaseProvider { get; set; }
+        public DatabaseProviderName DatabaseProvider { get; set; }
 
         /// <summary>
         /// Gets or sets the database connection string.
diff --git a/src/OrchardCore.Modules/OrchardCore.Setup/Controllers/SetupController.cs b/src/OrchardCore.Modules/OrchardCore.Setup/Controllers/SetupController.cs
index 6004a691a2b..4be0f0f9451 100644
--- a/src/OrchardCore.Modules/OrchardCore.Setup/Controllers/SetupController.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Setup/Controllers/SetupController.cs
@@ -26,7 +26,7 @@ public class SetupController : Controller
         private readonly ISetupService _setupService;
         private readonly ShellSettings _shellSettings;
         private readonly IShellHost _shellHost;
-        private IdentityOptions _identityOptions;
+        private readonly IdentityOptions _identityOptions;
         private readonly IEmailAddressValidator _emailAddressValidator;
         private readonly IEnumerable<DatabaseProvider> _databaseProviders;
         private readonly ILogger _logger;
@@ -59,13 +59,9 @@ public async Task<ActionResult> Index(string token)
             var recipes = await _setupService.GetSetupRecipesAsync();
             var defaultRecipe = recipes.FirstOrDefault(x => x.Tags.Contains("default")) ?? recipes.FirstOrDefault();
 
-            if (!string.IsNullOrWhiteSpace(_shellSettings["Secret"]))
+            if (!await ShouldProceedWithTokenAsync(token))
             {
-                if (string.IsNullOrEmpty(token) || !await IsTokenValid(token))
-                {
-                    _logger.LogWarning("An attempt to access '{TenantName}' without providing a secret was made", _shellSettings.Name);
-                    return StatusCode(404);
-                }
+                return StatusCode(404);
             }
 
             var model = new SetupViewModel
@@ -90,28 +86,14 @@ public async Task<ActionResult> Index(string token)
         [HttpPost, ActionName("Index")]
         public async Task<ActionResult> IndexPOST(SetupViewModel model)
         {
-            if (!string.IsNullOrWhiteSpace(_shellSettings["Secret"]))
+            if (!await ShouldProceedWithTokenAsync(model.Secret))
             {
-                if (string.IsNullOrEmpty(model.Secret) || !await IsTokenValid(model.Secret))
-                {
-                    _logger.LogWarning("An attempt to access '{TenantName}' without providing a valid secret was made", _shellSettings.Name);
-                    return StatusCode(404);
-                }
+                return StatusCode(404);
             }
 
             model.DatabaseProviders = _databaseProviders;
             model.Recipes = await _setupService.GetSetupRecipesAsync();
 
-            var selectedProvider = model.DatabaseProviders.FirstOrDefault(x => x.Value == model.DatabaseProvider);
-
-            if (!model.DatabaseConfigurationPreset)
-            {
-                if (selectedProvider != null && selectedProvider.HasConnectionString && String.IsNullOrWhiteSpace(model.ConnectionString))
-                {
-                    ModelState.AddModelError(nameof(model.ConnectionString), S["The connection string is mandatory for this provider."]);
-                }
-            }
-
             if (String.IsNullOrEmpty(model.Password))
             {
                 ModelState.AddModelError(nameof(model.Password), S["The password is required."]);
@@ -123,7 +105,7 @@ public async Task<ActionResult> IndexPOST(SetupViewModel model)
             }
 
             RecipeDescriptor selectedRecipe = null;
-            if (!string.IsNullOrEmpty(_shellSettings["RecipeName"]))
+            if (!String.IsNullOrEmpty(_shellSettings["RecipeName"]))
             {
                 selectedRecipe = model.Recipes.FirstOrDefault(x => x.Name == _shellSettings["RecipeName"]);
                 if (selectedRecipe == null)
@@ -169,8 +151,9 @@ public async Task<ActionResult> IndexPOST(SetupViewModel model)
                 }
             };
 
-            if (!string.IsNullOrEmpty(_shellSettings["ConnectionString"]))
+            if (!String.IsNullOrEmpty(_shellSettings["ConnectionString"]))
             {
+                model.DatabaseConfigurationPreset = true;
                 setupContext.Properties[SetupConstants.DatabaseProvider] = _shellSettings["DatabaseProvider"];
                 setupContext.Properties[SetupConstants.DatabaseConnectionString] = _shellSettings["ConnectionString"];
                 setupContext.Properties[SetupConstants.DatabaseTablePrefix] = _shellSettings["TablePrefix"];
@@ -184,7 +167,7 @@ public async Task<ActionResult> IndexPOST(SetupViewModel model)
 
             var executionId = await _setupService.SetupAsync(setupContext);
 
-            // Check if a component in the Setup failed
+            // Check if any Setup component failed (e.g., database connection validation)
             if (setupContext.Errors.Any())
             {
                 foreach (var error in setupContext.Errors)
@@ -215,9 +198,13 @@ private void CopyShellSettingsValues(SetupViewModel model)
             if (!String.IsNullOrEmpty(_shellSettings["DatabaseProvider"]))
             {
                 model.DatabaseConfigurationPreset = true;
-                model.DatabaseProvider = _shellSettings["DatabaseProvider"];
+                if (Enum.TryParse(_shellSettings["DatabaseProvider"], out DatabaseProviderName providerName))
+                {
+                    model.DatabaseProvider = providerName;
+                }
             }
-            else
+
+            if (!model.DatabaseProvider.HasValue)
             {
                 model.DatabaseProvider = model.DatabaseProviders.FirstOrDefault(p => p.IsDefault)?.Value;
             }
@@ -228,6 +215,21 @@ private void CopyShellSettingsValues(SetupViewModel model)
             }
         }
 
+        private async Task<bool> ShouldProceedWithTokenAsync(string token)
+        {
+            if (!String.IsNullOrWhiteSpace(_shellSettings["Secret"]))
+            {
+                if (String.IsNullOrEmpty(token) || !await IsTokenValid(token))
+                {
+                    _logger.LogWarning("An attempt to access '{TenantName}' without providing a secret was made", _shellSettings.Name);
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         private async Task<bool> IsTokenValid(string token)
         {
             try
diff --git a/src/OrchardCore.Modules/OrchardCore.Setup/ViewModels/SetupViewModel.cs b/src/OrchardCore.Modules/OrchardCore.Setup/ViewModels/SetupViewModel.cs
index efae2f92820..53b4b3b49d4 100644
--- a/src/OrchardCore.Modules/OrchardCore.Setup/ViewModels/SetupViewModel.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Setup/ViewModels/SetupViewModel.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
 using OrchardCore.Data;
 using OrchardCore.Recipes.Models;
 using OrchardCore.Setup.Annotations;
@@ -15,7 +16,7 @@ public class SetupViewModel
 
         public string Description { get; set; }
 
-        public string DatabaseProvider { get; set; }
+        public DatabaseProviderName? DatabaseProvider { get; set; }
 
         public string ConnectionString { get; set; }
 
@@ -24,6 +25,7 @@ public class SetupViewModel
         /// <summary>
         /// True if the database configuration is preset and can't be changed or displayed on the Setup screen.
         /// </summary>
+        [BindNever]
         public bool DatabaseConfigurationPreset { get; set; }
 
         [Required]
@@ -38,8 +40,10 @@ public class SetupViewModel
         [DataType(DataType.Password)]
         public string PasswordConfirmation { get; set; }
 
+        [BindNever]
         public IEnumerable<DatabaseProvider> DatabaseProviders { get; set; } = Enumerable.Empty<DatabaseProvider>();
 
+        [BindNever]
         public IEnumerable<RecipeDescriptor> Recipes { get; set; }
 
         public bool RecipeNamePreset { get; set; }
diff --git a/src/OrchardCore.Modules/OrchardCore.Setup/Views/Setup/Index.cshtml b/src/OrchardCore.Modules/OrchardCore.Setup/Views/Setup/Index.cshtml
index 8d8272d2e13..3450338a417 100644
--- a/src/OrchardCore.Modules/OrchardCore.Setup/Views/Setup/Index.cshtml
+++ b/src/OrchardCore.Modules/OrchardCore.Setup/Views/Setup/Index.cshtml
@@ -66,6 +66,7 @@
     var passwordTooltip = T["Password must have at least {0}.", passwordOptions];
 }
 <form asp-action="Index">
+
     <div class="bg-light p-2">
         @if (LocOptions.Value.SupportedUICultures.Count() > 1)
         {
@@ -92,6 +93,9 @@
         <h1>@T["Setup"]</h1>
         <p class="lead">@T["Please answer a few questions to configure your site."]</p>
     </div>
+
+    <div asp-validation-summary="ModelOnly"></div>
+
     @if (defaultRecipe == null)
     {
         <div class="alert alert-danger" role="alert">
@@ -173,7 +177,7 @@
 
             <div class="mb-3 col-md-6 tablePrefix" asp-validation-class-for="TablePrefix">
                 <label asp-for="TablePrefix">@T["Table Prefix"]</label>
-                <input asp-for="TablePrefix" class="form-select" />
+                <input asp-for="TablePrefix" class="form-control" />
                 <span asp-validation-for="TablePrefix" class="text-danger"></span>
                 <span class="text-muted form-text small">@T["You can specify a table prefix if you intend to reuse the same database for multiple sites."]</span>
             </div>
@@ -236,7 +240,7 @@
 </form>
 <script src="~/OrchardCore.Setup/Scripts/setup.min.js"></script>
 <script>
-    $(function(){
+    $(function() {
         $('#Password').strength({
             minLength: @(options.Password.RequiredLength),
             upperCase: @(options.Password.RequireUppercase ? "true" : "false"),
@@ -253,13 +257,13 @@
 
         toggleConnectionString = document.querySelector('#toggleConnectionString');
         if (toggleConnectionString) {
-            toggleConnectionString.addEventListener('click', function (e) {
+            toggleConnectionString.addEventListener('click', function(e) {
                 togglePasswordVisibility(document.querySelector('#ConnectionString'), document.querySelector('#toggleConnectionString'))
             });
         }
 
         togglePassword = document.querySelector('#togglePassword');
-        togglePassword.addEventListener('click', function (e) {
+        togglePassword.addEventListener('click', function(e) {
             togglePasswordVisibility(document.querySelector('#Password'), document.querySelector('#togglePassword'))
         });
 
diff --git a/src/OrchardCore.Modules/OrchardCore.Tenants/Controllers/ApiController.cs b/src/OrchardCore.Modules/OrchardCore.Tenants/Controllers/ApiController.cs
index 8a2958aed6f..7a9d7969c0c 100644
--- a/src/OrchardCore.Modules/OrchardCore.Tenants/Controllers/ApiController.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Tenants/Controllers/ApiController.cs
@@ -180,7 +180,9 @@ public async Task<ActionResult> Setup(SetupApiViewModel model)
                 databaseProvider = model.DatabaseProvider;
             }
 
-            var selectedProvider = _databaseProviders.FirstOrDefault(x => String.Equals(x.Value, databaseProvider, StringComparison.OrdinalIgnoreCase));
+            Enum.TryParse(databaseProvider, out DatabaseProviderName providerName);
+
+            var selectedProvider = _databaseProviders.FirstOrDefault(x => x.Value == providerName);
 
             if (selectedProvider == null)
             {
diff --git a/src/OrchardCore.Modules/OrchardCore.Tenants/Services/TenantValidator.cs b/src/OrchardCore.Modules/OrchardCore.Tenants/Services/TenantValidator.cs
index 55ea3af8499..b323c9b651e 100644
--- a/src/OrchardCore.Modules/OrchardCore.Tenants/Services/TenantValidator.cs
+++ b/src/OrchardCore.Modules/OrchardCore.Tenants/Services/TenantValidator.cs
@@ -6,6 +6,7 @@
 using Microsoft.Extensions.Localization;
 using OrchardCore.Data;
 using OrchardCore.Environment.Shell;
+using OrchardCore.Environment.Shell.Models;
 using OrchardCore.Mvc.ModelBinding;
 using OrchardCore.Tenants.ViewModels;
 
@@ -17,30 +18,24 @@ public class TenantValidator : ITenantValidator
 
         private readonly IShellHost _shellHost;
         private readonly IFeatureProfilesService _featureProfilesService;
-        private readonly IEnumerable<DatabaseProvider> _databaseProviders;
         private readonly IStringLocalizer<TenantValidator> S;
+        private readonly IDbConnectionValidator _dbConnectionValidator;
 
         public TenantValidator(
             IShellHost shellHost,
             IFeatureProfilesService featureProfilesService,
-            IEnumerable<DatabaseProvider> databaseProviders,
+            IDbConnectionValidator dbConnectionValidator,
             IStringLocalizer<TenantValidator> stringLocalizer)
         {
             _shellHost = shellHost;
             _featureProfilesService = featureProfilesService;
-            _databaseProviders = databaseProviders;
+            _dbConnectionValidator = dbConnectionValidator;
             S = stringLocalizer;
         }
 
         public async Task<IEnumerable<ModelError>> ValidateAsync(TenantViewModel model)
         {
             var errors = new List<ModelError>();
-            var selectedProvider = _databaseProviders.FirstOrDefault(x => x.Value == model.DatabaseProvider);
-
-            if (selectedProvider != null && selectedProvider.HasConnectionString && String.IsNullOrWhiteSpace(model.ConnectionString))
-            {
-                errors.Add(new ModelError(nameof(model.ConnectionString), S["The connection string is mandatory for this provider."]));
-            }
 
             if (String.IsNullOrWhiteSpace(model.Name))
             {
@@ -70,34 +65,62 @@ public async Task<IEnumerable<ModelError>> ValidateAsync(TenantViewModel model)
                 errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["Host and url prefix can not be empty at the same time."]));
             }
 
-            if (!String.IsNullOrWhiteSpace(model.RequestUrlPrefix))
+            if (!String.IsNullOrWhiteSpace(model.RequestUrlPrefix) && model.RequestUrlPrefix.Contains('/'))
             {
-                if (model.RequestUrlPrefix.Contains('/'))
-                {
-                    errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["The url prefix can not contain more than one segment."]));
-                }
+                errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["The url prefix can not contain more than one segment."]));
+            }
+
+            var allOtherSettings = _shellHost.GetAllSettings().Where(settings => !String.Equals(settings.Name, model.Name, StringComparison.OrdinalIgnoreCase));
+
+            if (allOtherSettings.Any(settings => String.Equals(settings.RequestUrlPrefix, model.RequestUrlPrefix?.Trim(), StringComparison.OrdinalIgnoreCase) && DoesUrlHostExist(settings.RequestUrlHost, model.RequestUrlHost)))
+            {
+                errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["A tenant with the same host and prefix already exists."]));
             }
 
-            if (shellSettings != null && model.IsNewTenant)
+            if (model.IsNewTenant)
             {
-                if (shellSettings.IsDefaultShell())
+                if (shellSettings != null)
                 {
-                    errors.Add(new ModelError(nameof(model.Name), S["The tenant name is in conflict with the 'Default' tenant."]));
+                    if (shellSettings.IsDefaultShell())
+                    {
+                        errors.Add(new ModelError(nameof(model.Name), S["The tenant name is in conflict with the 'Default' tenant."]));
+                    }
+                    else
+                    {
+                        errors.Add(new ModelError(nameof(model.Name), S["A tenant with the same name already exists."]));
+                    }
                 }
-                else
+
+                await AssertConnectionValidityAndApplyErrorsAsync(model.DatabaseProvider, model.ConnectionString, model.TablePrefix, errors);
+            }
+            else
+            {
+                if (shellSettings == null || shellSettings.State == TenantState.Uninitialized)
                 {
-                    errors.Add(new ModelError(nameof(model.Name), S["A tenant with the same name already exists."]));
+                    // While the tenant is in Uninitialized state, we still are able to change the database settings.
+                    // Let's validate the database for assurance.
+
+                    await AssertConnectionValidityAndApplyErrorsAsync(model.DatabaseProvider, model.ConnectionString, model.TablePrefix, errors);
                 }
             }
 
-            var allOtherSettings = _shellHost.GetAllSettings().Where(s => s != shellSettings);
+            return errors;
+        }
 
-            if (allOtherSettings.Any(tenant => String.Equals(tenant.RequestUrlPrefix, model.RequestUrlPrefix?.Trim(), StringComparison.OrdinalIgnoreCase) && DoesUrlHostExist(tenant.RequestUrlHost, model.RequestUrlHost)))
+        private async Task AssertConnectionValidityAndApplyErrorsAsync(string databaseProvider, string connectionString, string tablePrefix, List<ModelError> errors)
+        {
+            switch (await _dbConnectionValidator.ValidateAsync(databaseProvider, connectionString, tablePrefix))
             {
-                errors.Add(new ModelError(nameof(model.RequestUrlPrefix), S["A tenant with the same host and prefix already exists."]));
+                case DbConnectionValidatorResult.UnsupportedProvider:
+                    errors.Add(new ModelError(nameof(TenantViewModel.DatabaseProvider), S["The provided database provider is not supported."]));
+                    break;
+                case DbConnectionValidatorResult.InvalidConnection:
+                    errors.Add(new ModelError(nameof(TenantViewModel.ConnectionString), S["The provided connection string is invalid or server is unreachable."]));
+                    break;
+                case DbConnectionValidatorResult.DocumentFound:
+                    errors.Add(new ModelError(nameof(TenantViewModel.TablePrefix), S["The provided table prefix already exists."]));
+                    break;
             }
-
-            return errors;
         }
 
         private static bool DoesUrlHostExist(string urlHost, string modelUrlHost)
diff --git a/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProvider.cs b/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProvider.cs
index 3d995dafa80..15446d23529 100644
--- a/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProvider.cs
+++ b/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProvider.cs
@@ -3,7 +3,7 @@ namespace OrchardCore.Data
     public class DatabaseProvider
     {
         public string Name { get; set; }
-        public string Value { get; set; }
+        public DatabaseProviderName Value { get; set; }
         public bool HasConnectionString { get; set; }
         public bool HasTablePrefix { get; set; }
         public bool IsDefault { get; set; }
diff --git a/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProviderName.cs b/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProviderName.cs
new file mode 100644
index 00000000000..85ccf74b2f4
--- /dev/null
+++ b/src/OrchardCore/OrchardCore.Data.Abstractions/DatabaseProviderName.cs
@@ -0,0 +1,10 @@
+namespace OrchardCore.Data;
+
+public enum DatabaseProviderName
+{
+    None,
+    SqlConnection,
+    Sqlite,
+    MySql,
+    Postgres,
+}
diff --git a/src/OrchardCore/OrchardCore.Data.Abstractions/ServiceCollectionExtensions.cs b/src/OrchardCore/OrchardCore.Data.Abstractions/ServiceCollectionExtensions.cs
index ad890292787..463a38599ad 100644
--- a/src/OrchardCore/OrchardCore.Data.Abstractions/ServiceCollectionExtensions.cs
+++ b/src/OrchardCore/OrchardCore.Data.Abstractions/ServiceCollectionExtensions.cs
@@ -19,7 +19,7 @@ public static class ServiceCollectionExtensions
         /// <param name="isDefault">Whether the data provider is the default one.</param>
         /// <param name="sampleConnectionString">A sample connection string, e.g. Server={Server Name};Database={Database Name};IntegratedSecurity=true</param>
         /// <returns></returns>
-        public static IServiceCollection TryAddDataProvider(this IServiceCollection services, string name, string value, bool hasConnectionString, bool hasTablePrefix, bool isDefault, string sampleConnectionString = "")
+        public static IServiceCollection TryAddDataProvider(this IServiceCollection services, string name, DatabaseProviderName value, bool hasConnectionString, bool hasTablePrefix, bool isDefault, string sampleConnectionString = "")
         {
             for (var i = services.Count - 1; i >= 0; i--)
             {
diff --git a/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/DbConnectionValidatorResult.cs b/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/DbConnectionValidatorResult.cs
new file mode 100644
index 00000000000..6a6fe06a02f
--- /dev/null
+++ b/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/DbConnectionValidatorResult.cs
@@ -0,0 +1,22 @@
+namespace OrchardCore.Data;
+
+public enum DbConnectionValidatorResult
+{
+    // Unknown indicates that the connection string status is unknown or was not yet validated
+    Unknown,
+
+    // NoProvider indicated that the provider is missing
+    NoProvider,
+
+    // DocumentNotFound indicates that the connection string was valid, yet the Document table does not exist 
+    DocumentNotFound,
+
+    // DocumentFound indicates that the connection string was valid, yet the Document table exist
+    DocumentFound,
+
+    // InvalidConnection unable to open a connection to the given connection string
+    InvalidConnection,
+
+    // UnsupportedProvider indicated invalid or unsupported database provider
+    UnsupportedProvider
+}
diff --git a/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/IDbConnectionValidator.cs b/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/IDbConnectionValidator.cs
new file mode 100644
index 00000000000..6e4f42716b7
--- /dev/null
+++ b/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/IDbConnectionValidator.cs
@@ -0,0 +1,8 @@
+using System.Threading.Tasks;
+
+namespace OrchardCore.Data;
+
+public interface IDbConnectionValidator
+{
+    Task<DbConnectionValidatorResult> ValidateAsync(string databaseProvider, string connectionString, string tablePrefix);
+}
diff --git a/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/YesSqlOptions.cs b/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/YesSqlOptions.cs
index 3a6872e5299..f744e9894cc 100644
--- a/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/YesSqlOptions.cs
+++ b/src/OrchardCore/OrchardCore.Data.YesSql.Abstractions/YesSqlOptions.cs
@@ -17,4 +17,6 @@ public class YesSqlOptions
     public IAccessorFactory VersionAccessorFactory { get; set; }
 
     public IContentSerializer ContentSerializer { get; set; }
+
+    public string TablePrefixSeparator { get; set; } = "_";
 }
diff --git a/src/OrchardCore/OrchardCore.Data.YesSql/DbConnectionValidator.cs b/src/OrchardCore/OrchardCore.Data.YesSql/DbConnectionValidator.cs
new file mode 100644
index 00000000000..1ee7a2aa9b6
--- /dev/null
+++ b/src/OrchardCore/OrchardCore.Data.YesSql/DbConnectionValidator.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Data.SqlClient;
+using Microsoft.Data.Sqlite;
+using Microsoft.Extensions.Options;
+using MySqlConnector;
+using Npgsql;
+using OrchardCore.Data.YesSql.Abstractions;
+using YesSql;
+using YesSql.Provider.MySql;
+using YesSql.Provider.PostgreSql;
+using YesSql.Provider.Sqlite;
+using YesSql.Provider.SqlServer;
+using YesSql.Sql;
+
+namespace OrchardCore.Data;
+
+public class DbConnectionValidator : IDbConnectionValidator
+{
+    private readonly IEnumerable<DatabaseProvider> _databaseProviders;
+    private readonly ITableNameConvention _tableNameConvention;
+    private readonly YesSqlOptions _yesSqlOptions;
+
+    public DbConnectionValidator(
+        IEnumerable<DatabaseProvider> databaseProviders,
+        ITableNameConvention tableNameConvention,
+        IOptions<YesSqlOptions> yesSqlOptions
+        )
+    {
+        _databaseProviders = databaseProviders;
+        _tableNameConvention = tableNameConvention;
+        _yesSqlOptions = yesSqlOptions.Value;
+    }
+
+    public async Task<DbConnectionValidatorResult> ValidateAsync(string databaseProvider, string connectionString, string tablePrefix)
+    {
+        if (String.IsNullOrWhiteSpace(databaseProvider))
+        {
+            return DbConnectionValidatorResult.NoProvider;
+        }
+
+        if (!Enum.TryParse(databaseProvider, out DatabaseProviderName providerName) || providerName == DatabaseProviderName.None)
+        {
+            return DbConnectionValidatorResult.UnsupportedProvider;
+        }
+
+        var provider = _databaseProviders.FirstOrDefault(x => x.Value == providerName);
+
+        if (provider != null && !provider.HasConnectionString)
+        {
+            return DbConnectionValidatorResult.DocumentNotFound;
+        }
+
+        if (String.IsNullOrWhiteSpace(connectionString))
+        {
+            return DbConnectionValidatorResult.InvalidConnection;
+        }
+
+        var factory = GetFactory(providerName, connectionString);
+
+        using var connection = factory.CreateConnection();
+
+        try
+        {
+            await connection.OpenAsync();
+        }
+        catch
+        {
+            return DbConnectionValidatorResult.InvalidConnection;
+        }
+
+        var selectBuilder = GetSelectBuilderForDocumentTable(tablePrefix, providerName);
+
+        try
+        {
+            var selectCommand = connection.CreateCommand();
+            selectCommand.CommandText = selectBuilder.ToSqlString();
+
+            using var result = await selectCommand.ExecuteReaderAsync();
+
+            // at this point the query succeeded and the table exists
+            return DbConnectionValidatorResult.DocumentFound;
+        }
+        catch
+        {
+            // at this point we know that the document table does not exist
+
+            return DbConnectionValidatorResult.DocumentNotFound;
+        }
+    }
+
+    private ISqlBuilder GetSelectBuilderForDocumentTable(string tablePrefix, DatabaseProviderName providerName)
+    {
+        var selectBuilder = GetSqlBuilder(providerName, tablePrefix);
+
+        selectBuilder.Select();
+        selectBuilder.AddSelector("*");
+        selectBuilder.Table(_tableNameConvention.GetDocumentTable());
+        selectBuilder.Take("1");
+
+        return selectBuilder;
+    }
+
+    private static IConnectionFactory GetFactory(DatabaseProviderName providerName, string connectionString)
+    {
+        return providerName switch
+        {
+            DatabaseProviderName.SqlConnection => new DbConnectionFactory<SqlConnection>(connectionString),
+            DatabaseProviderName.MySql => new DbConnectionFactory<MySqlConnection>(connectionString),
+            DatabaseProviderName.Sqlite => new DbConnectionFactory<SqliteConnection>(connectionString),
+            DatabaseProviderName.Postgres => new DbConnectionFactory<NpgsqlConnection>(connectionString),
+            _ => throw new ArgumentOutOfRangeException("Unsupported Database Provider"),
+        };
+    }
+
+    private ISqlBuilder GetSqlBuilder(DatabaseProviderName providerName, string tablePrefix)
+    {
+        ISqlDialect dialect = providerName switch
+        {
+            DatabaseProviderName.SqlConnection => new SqlServerDialect(),
+            DatabaseProviderName.MySql => new MySqlDialect(),
+            DatabaseProviderName.Sqlite => new SqliteDialect(),
+            DatabaseProviderName.Postgres => new PostgreSqlDialect(),
+            _ => throw new ArgumentOutOfRangeException("Unsupported Database Provider"),
+        };
+
+        var prefix = String.Empty;
+
+        if (!String.IsNullOrEmpty(tablePrefix))
+        {
+            prefix = tablePrefix.Trim() + (_yesSqlOptions.TablePrefixSeparator ?? String.Empty);
+        }
+
+        return new SqlBuilder(prefix, dialect);
+    }
+}
diff --git a/src/OrchardCore/OrchardCore.Data.YesSql/OrchardCoreBuilderExtensions.cs b/src/OrchardCore/OrchardCore.Data.YesSql/OrchardCoreBuilderExtensions.cs
index e8895b8979c..9d95ae3df26 100644
--- a/src/OrchardCore/OrchardCore.Data.YesSql/OrchardCoreBuilderExtensions.cs
+++ b/src/OrchardCore/OrchardCore.Data.YesSql/OrchardCoreBuilderExtensions.cs
@@ -35,6 +35,7 @@ public static OrchardCoreBuilder AddDataAccess(this OrchardCoreBuilder builder)
         {
             builder.ConfigureServices(services =>
             {
+                services.AddScoped<IDbConnectionValidator, DbConnectionValidator>();
                 services.AddScoped<IDataMigrationManager, DataMigrationManager>();
                 services.AddScoped<IModularTenantEvents, AutomaticDataMigrations>();
 
@@ -42,10 +43,23 @@ public static OrchardCoreBuilder AddDataAccess(this OrchardCoreBuilder builder)
                 services.AddTransient<IConfigureOptions<SqliteOptions>, SqliteOptionsConfiguration>();
 
                 // Adding supported databases
-                services.TryAddDataProvider(name: "Sql Server", value: "SqlConnection", hasConnectionString: true, sampleConnectionString: "Server=localhost;Database=Orchard;User Id=username;Password=password", hasTablePrefix: true, isDefault: false);
-                services.TryAddDataProvider(name: "Sqlite", value: "Sqlite", hasConnectionString: false, hasTablePrefix: false, isDefault: true);
-                services.TryAddDataProvider(name: "MySql", value: "MySql", hasConnectionString: true, sampleConnectionString: "Server=localhost;Database=Orchard;Uid=username;Pwd=password", hasTablePrefix: true, isDefault: false);
-                services.TryAddDataProvider(name: "Postgres", value: "Postgres", hasConnectionString: true, sampleConnectionString: "Server=localhost;Port=5432;Database=Orchard;User Id=username;Password=password", hasTablePrefix: true, isDefault: false);
+                services.TryAddDataProvider(name: "Sql Server", value: DatabaseProviderName.SqlConnection, hasConnectionString: true, sampleConnectionString: "Server=localhost;Database=Orchard;User Id=username;Password=password", hasTablePrefix: true, isDefault: false);
+                services.TryAddDataProvider(name: "Sqlite", value: DatabaseProviderName.Sqlite, hasConnectionString: false, hasTablePrefix: false, isDefault: true);
+                services.TryAddDataProvider(name: "MySql", value: DatabaseProviderName.MySql, hasConnectionString: true, sampleConnectionString: "Server=localhost;Database=Orchard;Uid=username;Pwd=password", hasTablePrefix: true, isDefault: false);
+                services.TryAddDataProvider(name: "Postgres", value: DatabaseProviderName.Postgres, hasConnectionString: true, sampleConnectionString: "Server=localhost;Port=5432;Database=Orchard;User Id=username;Password=password", hasTablePrefix: true, isDefault: false);
+
+                // register ITableNameConvention
+                services.AddScoped(sp =>
+                {
+                    var yesSqlOptions = sp.GetService<IOptions<YesSqlOptions>>().Value;
+
+                    if (yesSqlOptions.TableNameConvention != null)
+                    {
+                        return yesSqlOptions.TableNameConvention;
+                    }
+
+                    return new YesSql.Configuration().TableNameConvention;
+                });
 
                 // Configuring data access
                 services.AddSingleton(sp =>
@@ -58,16 +72,22 @@ public static OrchardCoreBuilder AddDataAccess(this OrchardCoreBuilder builder)
                         return null;
                     }
 
-                    var storeConfiguration = GetStoreConfiguration(sp);
+                    var yesSqlOptions = sp.GetService<IOptions<YesSqlOptions>>().Value;
+                    var storeConfiguration = GetStoreConfiguration(sp, yesSqlOptions);
+
+                    if (!Enum.TryParse(shellSettings["DatabaseProvider"], out DatabaseProviderName providerName))
+                    {
+                        throw new ArgumentException("Unknown database provider: " + shellSettings["DatabaseProvider"]);
+                    }
 
-                    switch (shellSettings["DatabaseProvider"])
+                    switch (providerName)
                     {
-                        case "SqlConnection":
+                        case DatabaseProviderName.SqlConnection:
                             storeConfiguration
                                 .UseSqlServer(shellSettings["ConnectionString"], IsolationLevel.ReadUncommitted)
                                 .UseBlockIdGenerator();
                             break;
-                        case "Sqlite":
+                        case DatabaseProviderName.Sqlite:
                             var shellOptions = sp.GetService<IOptions<ShellOptions>>();
                             var sqliteOptions = sp.GetService<IOptions<SqliteOptions>>()?.Value ?? new SqliteOptions();
                             var option = shellOptions.Value;
@@ -85,12 +105,12 @@ public static OrchardCoreBuilder AddDataAccess(this OrchardCoreBuilder builder)
                                 .UseSqLite(connectionStringBuilder.ToString(), IsolationLevel.ReadUncommitted)
                                 .UseDefaultIdGenerator();
                             break;
-                        case "MySql":
+                        case DatabaseProviderName.MySql:
                             storeConfiguration
                                 .UseMySql(shellSettings["ConnectionString"], IsolationLevel.ReadUncommitted)
                                 .UseBlockIdGenerator();
                             break;
-                        case "Postgres":
+                        case DatabaseProviderName.Postgres:
                             storeConfiguration
                                 .UsePostgreSql(shellSettings["ConnectionString"], IsolationLevel.ReadUncommitted)
                                 .UseBlockIdGenerator();
@@ -99,9 +119,14 @@ public static OrchardCoreBuilder AddDataAccess(this OrchardCoreBuilder builder)
                             throw new ArgumentException("Unknown database provider: " + shellSettings["DatabaseProvider"]);
                     }
 
-                    if (!String.IsNullOrWhiteSpace(shellSettings["TablePrefix"]))
+                    if (!String.IsNullOrEmpty(shellSettings["TablePrefix"]))
                     {
-                        storeConfiguration = storeConfiguration.SetTablePrefix(shellSettings["TablePrefix"] + "_");
+                        // For backward compatibility, if the TablePrefixSeparator isn't set, we use _ as the default value.
+                        var seperator = shellSettings["TablePrefixSeparator"] ?? "_";
+
+                        var tablePrefix = shellSettings["TablePrefix"].Trim() + (seperator ?? String.Empty);
+
+                        storeConfiguration = storeConfiguration.SetTablePrefix(tablePrefix);
                     }
 
                     var store = StoreFactory.CreateAndInitializeAsync(storeConfiguration).GetAwaiter().GetResult();
@@ -159,10 +184,8 @@ public static OrchardCoreBuilder AddDataAccess(this OrchardCoreBuilder builder)
             return builder;
         }
 
-        private static IConfiguration GetStoreConfiguration(IServiceProvider sp)
+        private static IConfiguration GetStoreConfiguration(IServiceProvider sp, YesSqlOptions yesSqlOptions)
         {
-            var yesSqlOptions = sp.GetService<IOptions<YesSqlOptions>>().Value;
-
             var storeConfiguration = new YesSql.Configuration
             {
                 CommandsPageSize = yesSqlOptions.CommandsPageSize,
diff --git a/src/OrchardCore/OrchardCore.Setup.Core/SetupService.cs b/src/OrchardCore/OrchardCore.Setup.Core/SetupService.cs
index a4124a42379..81bb363cd6c 100644
--- a/src/OrchardCore/OrchardCore.Setup.Core/SetupService.cs
+++ b/src/OrchardCore/OrchardCore.Setup.Core/SetupService.cs
@@ -7,7 +7,10 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Localization;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using OrchardCore.Abstractions.Setup;
+using OrchardCore.Data;
+using OrchardCore.Data.YesSql.Abstractions;
 using OrchardCore.Environment.Shell;
 using OrchardCore.Environment.Shell.Builders;
 using OrchardCore.Environment.Shell.Descriptor;
@@ -34,6 +37,8 @@ public class SetupService : ISetupService
         private readonly IStringLocalizer S;
         private readonly IHostApplicationLifetime _applicationLifetime;
         private readonly IHttpContextAccessor _httpContextAccessor;
+        private readonly IDbConnectionValidator _dbConnectionValidator;
+        private readonly YesSqlOptions _yesSqlOptions;
         private readonly string _applicationName;
         private IEnumerable<RecipeDescriptor> _recipes;
 
@@ -49,6 +54,8 @@ public class SetupService : ISetupService
         /// <param name="stringLocalizer">The <see cref="IStringLocalizer"/>.</param>
         /// <param name="applicationLifetime">The <see cref="IHostApplicationLifetime"/>.</param>
         /// <param name="httpContextAccessor">The <see cref="IHttpContextAccessor"/>.</param>
+        /// <param name="dbConnectionValidator">The <see cref="IDbConnectionValidator"/>.</param>
+        /// <param name="yesSqlOptions">The <see cref="YesSqlOptions"/>.</param>
         public SetupService(
             IShellHost shellHost,
             IHostEnvironment hostingEnvironment,
@@ -58,7 +65,9 @@ public class SetupService : ISetupService
             ILogger<SetupService> logger,
             IStringLocalizer<SetupService> stringLocalizer,
             IHostApplicationLifetime applicationLifetime,
-            IHttpContextAccessor httpContextAccessor)
+            IHttpContextAccessor httpContextAccessor,
+            IDbConnectionValidator dbConnectionValidator,
+            IOptions<YesSqlOptions> yesSqlOptions)
         {
             _shellHost = shellHost;
             _applicationName = hostingEnvironment.ApplicationName;
@@ -69,6 +78,8 @@ public class SetupService : ISetupService
             S = stringLocalizer;
             _applicationLifetime = applicationLifetime;
             _httpContextAccessor = httpContextAccessor;
+            _dbConnectionValidator = dbConnectionValidator;
+            _yesSqlOptions = yesSqlOptions.Value;
         }
 
         /// <inheritdoc />
@@ -150,16 +161,34 @@ private async Task<string> SetupInternalAsync(SetupContext context)
 
             var shellSettings = new ShellSettings(context.ShellSettings);
 
-            if (string.IsNullOrEmpty(shellSettings["DatabaseProvider"]))
+            shellSettings["TablePrefixSeparator"] = _yesSqlOptions.TablePrefixSeparator ?? String.Empty;
+
+            if (String.IsNullOrWhiteSpace(shellSettings["DatabaseProvider"]))
             {
                 shellSettings["DatabaseProvider"] = context.Properties.TryGetValue(SetupConstants.DatabaseProvider, out var databaseProvider) ? databaseProvider?.ToString() : String.Empty;
                 shellSettings["ConnectionString"] = context.Properties.TryGetValue(SetupConstants.DatabaseConnectionString, out var databaseConnectionString) ? databaseConnectionString?.ToString() : String.Empty;
                 shellSettings["TablePrefix"] = context.Properties.TryGetValue(SetupConstants.DatabaseTablePrefix, out var databaseTablePrefix) ? databaseTablePrefix?.ToString() : String.Empty;
             }
 
-            if (String.IsNullOrWhiteSpace(shellSettings["DatabaseProvider"]))
+            switch (await _dbConnectionValidator.ValidateAsync(shellSettings["DatabaseProvider"], shellSettings["ConnectionString"], shellSettings["TablePrefix"]))
+            {
+                case DbConnectionValidatorResult.NoProvider:
+                    context.Errors.Add(String.Empty, S["DatabaseProvider setting is required."]);
+                    break;
+                case DbConnectionValidatorResult.UnsupportedProvider:
+                    context.Errors.Add(String.Empty, S["The provided database provider is not supported."]);
+                    break;
+                case DbConnectionValidatorResult.InvalidConnection:
+                    context.Errors.Add(String.Empty, S["The provided connection string is invalid or server is unreachable."]);
+                    break;
+                case DbConnectionValidatorResult.DocumentFound:
+                    context.Errors.Add(String.Empty, S["The provided database table is already in use."]);
+                    break;
+            }
+
+            if (context.Errors.Any())
             {
-                throw new ArgumentException("DatabaseProvider is required");
+                return null;
             }
 
             // Creating a standalone environment based on a "minimum shell descriptor".
@@ -192,7 +221,7 @@ private async Task<string> SetupInternalAsync(SetupContext context)
                         // unless the recipe is executing?
 
                         _logger.LogError(e, "An error occurred while initializing the datastore.");
-                        context.Errors.Add("DatabaseProvider", S["An error occurred while initializing the datastore: {0}", e.Message]);
+                        context.Errors.Add(String.Empty, S["An error occurred while initializing the datastore: {0}", e.Message]);
                         return;
                     }
 
diff --git a/test/OrchardCore.Tests/Modules/OrchardCore.Tenants/Services/TenantValidatorTests.cs b/test/OrchardCore.Tests/Modules/OrchardCore.Tenants/Services/TenantValidatorTests.cs
index 493d9e8a528..ddae5327993 100644
--- a/test/OrchardCore.Tests/Modules/OrchardCore.Tenants/Services/TenantValidatorTests.cs
+++ b/test/OrchardCore.Tests/Modules/OrchardCore.Tenants/Services/TenantValidatorTests.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Localization;
 using Moq;
 using OrchardCore.Data;
@@ -9,15 +10,19 @@
 using OrchardCore.Environment.Shell.Models;
 using OrchardCore.Tenants.Services;
 using OrchardCore.Tenants.ViewModels;
+using OrchardCore.Tests.Apis.Context;
 using Xunit;
 
 namespace OrchardCore.Modules.Tenants.Services.Tests
 {
-    public class TenantValidatorTests
+    public class TenantValidatorTests : SiteContext
     {
-        private readonly Dictionary<string, ShellSettings> _shellSettings = new(StringComparer.OrdinalIgnoreCase);
+        public static IShellHost ShellHost { get; }
 
-        public TenantValidatorTests() => SeedTenants();
+        static TenantValidatorTests()
+        {
+            ShellHost = Site.Services.GetRequiredService<IShellHost>();
+        }
 
         [Theory]
         [InlineData("Tenant1", "tenant1", "", "Feature Profile", new[] { "A tenant with the same name already exists." })]
@@ -41,9 +46,12 @@ public class TenantValidatorTests
         public async Task TenantValidationFailsIfInvalidConfigurationsWasProvided(string name, string urlPrefix, string hostName, string featureProfile, string[] errorMessages)
         {
             // Arrange
-            var tenantValidator = CreateTenantValidator();
+            await ShellHost.InitializeAsync();
+            await SeedTenantsAsync();
 
-            // Act & Assert
+            var tenantValidator = CreateTenantValidator(defaultTenant: false);
+
+            // Act
             var viewModel = new EditTenantViewModel
             {
                 Name = name,
@@ -70,6 +78,9 @@ public async Task TenantValidationFailsIfInvalidConfigurationsWasProvided(string
         public async Task DuplicateTenantHostOrPrefixShouldFailValidation(bool isNewTenant)
         {
             // Arrange
+            await ShellHost.InitializeAsync();
+            await SeedTenantsAsync();
+
             var tenantValidator = CreateTenantValidator();
 
             var viewModel = new EditTenantViewModel
@@ -84,22 +95,13 @@ public async Task DuplicateTenantHostOrPrefixShouldFailValidation(bool isNewTena
             // Act
             var errors = await tenantValidator.ValidateAsync(viewModel);
 
-            // Asserts
+            // Assert
             Assert.Single(errors);
             Assert.Equal("A tenant with the same host and prefix already exists.", errors.Single().Message);
         }
 
-        private delegate bool MockShellHostTryGetSettings(string name, out ShellSettings settings);
-
-        private TenantValidator CreateTenantValidator()
+        private static TenantValidator CreateTenantValidator(bool defaultTenant = true)
         {
-            var shellHostMock = new Mock<IShellHost>();
-            shellHostMock.Setup(h => h.GetAllSettings()).Returns(_shellSettings.Values.ToArray());
-
-            shellHostMock.Setup(h => h.TryGetSettings(It.IsAny<string>(), out It.Ref<ShellSettings>.IsAny))
-                .Returns(new MockShellHostTryGetSettings((string name, out ShellSettings shellSettings) =>
-                    _shellSettings.TryGetValue(name, out shellSettings)));
-
             var featureProfilesServiceMock = new Mock<IFeatureProfilesService>();
             featureProfilesServiceMock.Setup(fp => fp.GetFeatureProfilesAsync())
                 .Returns(Task.FromResult((IDictionary<string, FeatureProfile>)new Dictionary<string, FeatureProfile>
@@ -115,20 +117,28 @@ private TenantValidator CreateTenantValidator()
                 .Setup(l => l[It.IsAny<string>(), It.IsAny<object[]>()])
                 .Returns<string, object[]>((n, a) => new LocalizedString(n, n));
 
+            var shellSettings = defaultTenant
+                ? ShellHost.GetSettings(ShellHelper.DefaultShellName)
+                : new ShellSettings();
+
+            var connectionFactory = new Mock<IDbConnectionValidator>();
+            connectionFactory.Setup(l => l.ValidateAsync(shellSettings["ProviderName"], shellSettings["ConnectionName"], shellSettings["TablePrefix"]));
+
             return new TenantValidator(
-                shellHostMock.Object,
+                ShellHost,
                 featureProfilesServiceMock.Object,
-                Enumerable.Empty<DatabaseProvider>(),
-                stringLocalizerMock.Object);
+                connectionFactory.Object,
+                stringLocalizerMock.Object
+                );
         }
 
-        private void SeedTenants()
+        private static async Task SeedTenantsAsync()
         {
-            _shellSettings.Add(ShellHelper.DefaultShellName, new ShellSettings { Name = ShellHelper.DefaultShellName });
-            _shellSettings.Add("Tenant1", new ShellSettings { Name = "Tenant1" });
-            _shellSettings.Add("Tenant2", new ShellSettings { Name = "Tenant2", RequestUrlPrefix = String.Empty, RequestUrlHost = "example2.com" });
-            _shellSettings.Add("Tenant3", new ShellSettings { Name = "Tenant3", RequestUrlPrefix = "tenant3", RequestUrlHost = String.Empty });
-            _shellSettings.Add("Tenant4", new ShellSettings { Name = "Tenant4", RequestUrlPrefix = "tenant4", RequestUrlHost = "example4.com,example5.com" });
+            await ShellHost.GetOrCreateShellContextAsync(new ShellSettings { Name = "Tenant1", State = TenantState.Uninitialized });
+            await ShellHost.GetOrCreateShellContextAsync(new ShellSettings { Name = "Tenant2", State = TenantState.Uninitialized, RequestUrlPrefix = String.Empty, RequestUrlHost = "example2.com" });
+            await ShellHost.GetOrCreateShellContextAsync(new ShellSettings { Name = "Tenant2", State = TenantState.Uninitialized, RequestUrlPrefix = String.Empty, RequestUrlHost = "example2.com" });
+            await ShellHost.GetOrCreateShellContextAsync(new ShellSettings { Name = "Tenant3", State = TenantState.Uninitialized, RequestUrlPrefix = "tenant3", RequestUrlHost = String.Empty });
+            await ShellHost.GetOrCreateShellContextAsync(new ShellSettings { Name = "Tenant4", State = TenantState.Uninitialized, RequestUrlPrefix = "tenant4", RequestUrlHost = "example4.com,example5.com" });
         }
     }
 }